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

package/dist/cabinet/definition.js

@@ -10,8 +10,9 @@ import { cabinetPaint } from './paint';
 import { cabinetModuleParametrics, cabinetParametrics } from './parametrics';
 import useCabinetPlacementType from './placement-type';
 import { cabinetQuickActions } from './quick-actions';
-import { moduleSideOpen } from './run-layout';
-import { backAlignZ, bumpCabinetRunLayoutRevision, cabinetMetadataRecord, cabinetModulesForRun, totalCabinetHeight as cabinetTotalHeight, cornerLinkedSourceModuleForRun, resolveCabinetType, runModuleBaseY, syncCornerRunsFromSourceModule, wallChildOf, } from './run-ops';
+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 { cabinetSceneAction } from './scene-action';
 import { CabinetModuleNode, CabinetNode } from './schema';
 import { cabinetSlots } from './slots';
@@ -131,10 +132,9 @@ const SIDE_HANDLE_OFFSET = 0.18;
 const HEIGHT_HANDLE_OFFSET = 0.22;
 const ROTATE_CORNER_OFFSET = 0.32;
 const ROTATE_RING_OFFSET = 0.04;
-const MIN_CABINET_WIDTH = 0.3;
-const MIN_CABINET_DEPTH = 0.3;
 const MIN_CABINET_CARCASS_HEIGHT = 0.4;
 const CABINET_ADJACENCY_EPSILON = 1e-4;
+const CABINET_DEPTH_SNAP_THRESHOLD = 0.02;
 function isCabinetModule(node) {
     return node?.type === 'cabinet-module';
 }
@@ -370,6 +370,17 @@ function cabinetLocalBounds(node, nodes) {
                 includeChildRunBounds(child, nodes, bounds);
         }
     }
+    if (isCabinetModule(node) && nodes) {
+        for (const childId of node.children ?? []) {
+            const child = nodes[childId];
+            if (isCabinetModule(child)) {
+                includeCabinetModuleBounds(child, nodes, [0, 0, 0], bounds);
+            }
+            else if (isCabinetRun(child)) {
+                includeChildRunBounds(child, nodes, bounds);
+            }
+        }
+    }
     const width = Math.max(0.01, bounds.maxX - bounds.minX);
     const height = Math.max(0.01, bounds.maxY - bounds.minY);
     const depth = Math.max(0.01, bounds.maxZ - bounds.minZ);
@@ -412,22 +423,260 @@ function cabinetModuleSideOpen(module, side, sceneApi) {
         return true;
     return moduleSideOpen(cabinetModulesForRun(parent, sceneApi.nodes()), module.id, side, CABINET_ADJACENCY_EPSILON);
 }
-function commitRunResize(run, patch, sceneApi) {
+function cabinetModuleConnectedNeighbor(module, side, sceneApi) {
+    const parent = module.parentId ? sceneApi.get(module.parentId) : undefined;
+    if (!isCabinetRun(parent))
+        return undefined;
+    const modules = sortRunModules(cabinetModulesForRun(parent, sceneApi.nodes()));
+    const index = modules.findIndex((entry) => entry.id === module.id);
+    if (index < 0 || cabinetModuleSideOpen(module, side, sceneApi))
+        return undefined;
+    return side === 'left' ? modules[index - 1] : modules[index + 1];
+}
+function cabinetWidthConnectedNeighbor(module, side, sceneApi) {
+    const parent = module.parentId ? sceneApi.get(module.parentId) : undefined;
+    if (isCabinetRun(parent))
+        return cabinetModuleConnectedNeighbor(module, side, sceneApi);
+    if (!isCabinetModule(parent))
+        return undefined;
+    if (wallChildOf(parent, sceneApi.nodes())?.id !== module.id)
+        return undefined;
+    const connectedHost = cabinetModuleConnectedNeighbor(parent, side, sceneApi);
+    if (!connectedHost || isCabinetWidthFiller(connectedHost))
+        return undefined;
+    return wallChildOf(connectedHost, sceneApi.nodes()) ?? undefined;
+}
+function cabinetModuleRunLocalCenterX(module, sceneApi) {
+    const parent = module.parentId ? sceneApi.get(module.parentId) : undefined;
+    if (isCabinetRun(parent))
+        return module.position[0];
+    if (!isCabinetModule(parent))
+        return null;
+    const run = parent.parentId ? sceneApi.get(parent.parentId) : undefined;
+    return isCabinetRun(run) ? parent.position[0] + module.position[0] : null;
+}
+function cabinetWallWidthGap(module, side, sceneApi) {
+    const parent = module.parentId ? sceneApi.get(module.parentId) : undefined;
+    const isWallModule = (isCabinetRun(parent) && parent.runTier === 'wall') ||
+        (isCabinetModule(parent) && wallChildOf(parent, sceneApi.nodes())?.id === module.id);
+    if (!isWallModule)
+        return 0;
+    const connected = cabinetWidthConnectedNeighbor(module, side, sceneApi);
+    if (!connected || isCabinetWidthFiller(connected))
+        return 0;
+    const moduleCenter = cabinetModuleRunLocalCenterX(module, sceneApi);
+    const connectedCenter = cabinetModuleRunLocalCenterX(connected, sceneApi);
+    if (moduleCenter === null || connectedCenter === null)
+        return 0;
+    const direction = side === 'right' ? 1 : -1;
+    return Math.max(0, direction * (connectedCenter - moduleCenter) - (module.width + connected.width) / 2);
+}
+function isCabinetWidthFiller(module) {
+    return (module.moduleKind === 'corner-filler' ||
+        module.name === 'Corner Filler' ||
+        module.name === 'Wall Bridge Filler' ||
+        module.name === 'Corner Wall Filler');
+}
+function cabinetNodeAttachedToAncestor(node, ancestorId, nodes) {
+    let current = node;
+    const visited = new Set();
+    while (current.parentId) {
+        const currentId = current.id;
+        if (visited.has(currentId))
+            return false;
+        visited.add(currentId);
+        const parent = nodes[current.parentId];
+        if (parent?.type !== 'cabinet' && parent?.type !== 'cabinet-module')
+            return false;
+        if (!(parent.children ?? []).includes(currentId))
+            return false;
+        if (parent.id === ancestorId)
+            return true;
+        current = parent;
+    }
+    return false;
+}
+function cabinetSubtreeHasNamedFiller(root, name, sceneApi) {
+    const pending = [...(root.children ?? [])];
+    const visited = new Set();
+    while (pending.length > 0) {
+        const id = pending.pop();
+        if (visited.has(id))
+            continue;
+        visited.add(id);
+        const node = sceneApi.get(id);
+        if (!node)
+            continue;
+        if (node.type === 'cabinet-module' && isCabinetWidthFiller(node) && node.name === name) {
+            return true;
+        }
+        if (node.type === 'cabinet' || node.type === 'cabinet-module') {
+            pending.push(...(node.children ?? []));
+        }
+    }
+    return false;
+}
+function wallCabinetSideHasFiller(hostModule, side, sceneApi) {
+    const hostRun = hostModule.parentId
+        ? sceneApi.get(hostModule.parentId)
+        : undefined;
+    if (!hostRun || !isCabinetRun(hostRun))
+        return false;
+    const connected = cabinetModuleConnectedNeighbor(hostModule, side, sceneApi);
+    if (connected &&
+        isCabinetWidthFiller(connected) &&
+        cabinetSubtreeHasNamedFiller(connected, 'Corner Wall Filler', sceneApi)) {
+        return true;
+    }
+    const nodes = sceneApi.nodes();
+    for (const candidate of Object.values(nodes)) {
+        if (candidate?.type !== 'cabinet')
+            continue;
+        const derived = cabinetMetadataRecord(candidate.metadata).cabinetCornerDerivedRun;
+        if (!derived || typeof derived !== 'object' || Array.isArray(derived))
+            continue;
+        if (derived.role !== 'bridge' ||
+            derived.side !== side ||
+            derived.sourceModuleId !== hostModule.id ||
+            derived.sourceRunId !== hostRun.id ||
+            !cabinetNodeAttachedToAncestor(candidate, hostRun.id, nodes)) {
+            continue;
+        }
+        if (cabinetModulesForRun(candidate, nodes).some((entry) => entry.name === 'Wall Bridge Filler')) {
+            return true;
+        }
+    }
+    return false;
+}
+function cabinetModuleSideHasCornerFiller(module, side, sceneApi) {
+    const parent = module.parentId ? sceneApi.get(module.parentId) : undefined;
+    if (isCabinetModule(parent)) {
+        return wallCabinetSideHasFiller(parent, side, sceneApi);
+    }
+    if (!isCabinetRun(parent))
+        return false;
+    const connected = cabinetModuleConnectedNeighbor(module, side, sceneApi);
+    if (connected && isCabinetWidthFiller(connected)) {
+        return true;
+    }
+    for (const candidate of Object.values(sceneApi.nodes())) {
+        if (candidate?.type !== 'cabinet')
+            continue;
+        const derived = cabinetMetadataRecord(candidate.metadata).cabinetCornerDerivedRun;
+        if (!derived || typeof derived !== 'object' || Array.isArray(derived))
+            continue;
+        if (candidate.parentId !== parent.id ||
+            !(parent.children ?? []).includes(candidate.id) ||
+            derived.role !== 'base-leg' ||
+            derived.side !== side ||
+            derived.sourceModuleId !== module.id ||
+            derived.sourceRunId !== parent.id) {
+            continue;
+        }
+        if (cabinetModulesForRun(candidate, sceneApi.nodes()).some((entry) => entry.moduleKind === 'corner-filler')) {
+            return true;
+        }
+    }
+    return false;
+}
+function connectedCabinetWidthResize(module, side, delta, sceneApi) {
+    const connected = cabinetWidthConnectedNeighbor(module, side, sceneApi);
+    if (!connected || isCabinetWidthFiller(connected))
+        return null;
+    const direction = side === 'right' ? 1 : -1;
+    return {
+        module: connected,
+        patch: {
+            width: connected.width - delta,
+            position: [
+                connected.position[0] + (direction * delta) / 2,
+                connected.position[1],
+                connected.position[2],
+            ],
+        },
+    };
+}
+function wallCabinetWidthOverride(module, width, sceneApi) {
+    const parent = module.parentId
+        ? sceneApi.get(module.parentId)
+        : undefined;
+    if (!parent || !isCabinetRun(parent) || resolveCabinetType(module, parent) !== 'base')
+        return null;
+    const wallChild = wallChildOf(module, sceneApi.nodes());
+    return wallChild ? [wallChild.id, { width }] : null;
+}
+function parentRunGeometryPreviewOverride(node, sceneApi) {
+    if (!isCabinetModule(node) || !node.parentId)
+        return null;
+    const parent = sceneApi.get(node.parentId);
+    return isCabinetRun(parent) ? [parent.id, {}] : null;
+}
+function sharedDepthBounds(referenceDepth, targets, nodes) {
+    const depthOwners = targets.flatMap((target) => {
+        if (!isCabinetRun(target))
+            return [target];
+        const modules = cabinetModulesForRun(target, nodes);
+        return modules.length > 0 ? [target, ...modules] : [target];
+    });
+    const minDelta = Math.max(...depthOwners.map((target) => MIN_CABINET_DEPTH - target.depth));
+    const maxDelta = Math.min(...depthOwners.map((target) => cabinetResizeUpperBound(target.depth, MAX_CABINET_DEPTH) - target.depth));
+    return {
+        min: referenceDepth + minDelta,
+        max: referenceDepth + maxDelta,
+    };
+}
+function depthDeltaRunOverrides(run, nodes, depthDelta) {
+    const overrides = [];
+    for (const module of cabinetModulesForRun(run, nodes)) {
+        const depth = module.depth + depthDelta;
+        const positionZ = backAnchoredModuleZ(module.position[2], module.depth, depth);
+        const parentShiftZ = positionZ - module.position[2];
+        overrides.push([
+            module.id,
+            {
+                depth,
+                position: [module.position[0], module.position[1], positionZ],
+            },
+        ]);
+        for (const childId of module.children ?? []) {
+            const child = nodes[childId];
+            if (child?.type !== 'cabinet')
+                continue;
+            overrides.push([
+                child.id,
+                {
+                    position: [child.position[0], child.position[1], child.position[2] - parentShiftZ],
+                },
+            ]);
+        }
+        const wallChild = wallChildOf(module, nodes);
+        if (wallChild) {
+            overrides.push([
+                wallChild.id,
+                {
+                    position: [
+                        wallChild.position[0],
+                        wallChild.position[1],
+                        backAlignZ(depth, wallChild.depth),
+                    ],
+                },
+            ]);
+        }
+    }
+    return overrides;
+}
+function commitRunResize(run, patch, sceneApi, options = {}) {
     sceneApi.update(run.id, patch);
     const nextRun = { ...run, ...patch };
     const syncDepth = typeof patch.depth === 'number';
     const syncHeight = typeof patch.carcassHeight === 'number';
     const syncPosition = patch.showPlinth !== undefined || typeof patch.plinthHeight === 'number';
     if (syncDepth || syncHeight || syncPosition) {
+        const depthOverrides = new Map(syncDepth ? backAlignedRunDepthOverrides(run, sceneApi.nodes(), nextRun.depth) : []);
         for (const module of cabinetModulesForRun(run, sceneApi.nodes())) {
             const modulePatch = {};
             if (syncDepth) {
-                modulePatch.depth = nextRun.depth;
-                modulePatch.position = [
-                    module.position[0],
-                    module.position[1],
-                    backAnchoredModuleZ(module.position[2], module.depth, nextRun.depth),
-                ];
+                Object.assign(modulePatch, depthOverrides.get(module.id));
             }
             if (syncHeight) {
                 modulePatch.carcassHeight = Math.max(nextRun.carcassHeight, minCabinetCarcassHeightForStack(module));
@@ -453,19 +702,37 @@ function commitRunResize(run, patch, sceneApi) {
                 }
             }
         }
+        if (syncDepth) {
+            for (const [id, depthPatch] of depthOverrides) {
+                if (sceneApi.get(id)?.type !== 'cabinet')
+                    continue;
+                sceneApi.update(id, depthPatch);
+            }
+        }
     }
     if (syncDepth || syncHeight || syncPosition) {
         bumpCabinetRunLayoutRevision(sceneApi, nextRun);
-        const cornerSource = cornerLinkedSourceModuleForRun(nextRun, sceneApi.nodes());
-        if (cornerSource) {
-            syncCornerRunsFromSourceModule({
-                module: cornerSource,
-                run: nextRun,
-                sceneApi,
-            });
-        }
+        syncCornerRunsFromRunSources({
+            baseLayout: options.cornerSync ?? 'full',
+            run: nextRun,
+            sceneApi,
+        });
     }
 }
+function commitRunDepthDelta(run, depth, sceneApi, options = {}) {
+    const depthDelta = depth - run.depth;
+    for (const [id, patch] of depthDeltaRunOverrides(run, sceneApi.nodes(), depthDelta)) {
+        sceneApi.update(id, patch);
+    }
+    sceneApi.update(run.id, { depth });
+    const nextRun = { ...run, depth };
+    bumpCabinetRunLayoutRevision(sceneApi, nextRun);
+    syncCornerRunsFromRunSources({
+        baseLayout: options.cornerSync ?? 'full',
+        run: nextRun,
+        sceneApi,
+    });
+}
 function commitModuleResize(module, patch, sceneApi) {
     const nodes = sceneApi.nodes();
     const parent = module.parentId ? nodes[module.parentId] : undefined;
@@ -479,23 +746,13 @@ function commitModuleResize(module, patch, sceneApi) {
     }
     if (typeof patch.width === 'number') {
         sceneApi.update(module.id, patch);
-        const wallChild = wallChildOf(module, sceneApi.nodes());
-        if (wallChild) {
-            sceneApi.update(wallChild.id, {
-                width: patch.width,
-                position: [
-                    wallChild.position[0],
-                    wallChild.position[1],
-                    backAlignZ(patch.depth ?? module.depth, wallChild.depth),
-                ],
-            });
+        if (resolveCabinetType(module, parentRun) === 'base') {
+            const wallChild = wallChildOf(module, sceneApi.nodes());
+            if (wallChild) {
+                sceneApi.update(wallChild.id, { width: patch.width });
+            }
         }
         bumpCabinetRunLayoutRevision(sceneApi, parentRun);
-        syncCornerRunsFromSourceModule({
-            module: sceneApi.get(module.id) ?? module,
-            run: sceneApi.get(parentRun.id) ?? parentRun,
-            sceneApi,
-        });
         return;
     }
     const modulePatch = { ...patch };
@@ -509,8 +766,6 @@ function commitModuleResize(module, patch, sceneApi) {
     sceneApi.update(module.id, modulePatch);
     if (resolveCabinetType(module, parentRun) === 'base') {
         const runPatch = {};
-        if (typeof patch.depth === 'number')
-            runPatch.depth = patch.depth;
         if (typeof patch.carcassHeight === 'number') {
             runPatch.carcassHeight = patch.carcassHeight;
         }
@@ -558,17 +813,71 @@ function cabinetWidthHandle(side) {
         kind: 'linear-resize',
         axis: 'x',
         anchor: side === 'right' ? 'min' : 'max',
-        min: MIN_CABINET_WIDTH,
+        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));
+        },
+        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);
+        },
         currentValue: (node) => node.width,
-        apply: (node, width) => ({
-            width,
-            position: [
-                node.position[0] + (sign * (width - node.width)) / 2,
-                node.position[1],
-                node.position[2],
-            ],
-        }),
-        commit: commitCabinetResize,
+        apply: (node, width, sceneApi) => {
+            const gap = isCabinetModule(node) ? cabinetWallWidthGap(node, side, sceneApi) : 0;
+            const effectiveWidth = width + gap;
+            return {
+                width: effectiveWidth,
+                position: [
+                    node.position[0] + (sign * (effectiveWidth - node.width)) / 2,
+                    node.position[1],
+                    node.position[2],
+                ],
+            };
+        },
+        previewOverrides: (node, width, sceneApi) => {
+            if (!isCabinetModule(node))
+                return [];
+            const overrides = [];
+            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);
+            const connectedResize = connectedCabinetWidthResize(node, side, width - node.width, sceneApi);
+            if (connectedResize) {
+                overrides.push([
+                    connectedResize.module.id,
+                    connectedResize.patch,
+                ]);
+                const connectedWallOverride = wallCabinetWidthOverride(connectedResize.module, connectedResize.patch.width, sceneApi);
+                if (connectedWallOverride)
+                    overrides.push(connectedWallOverride);
+            }
+            return overrides;
+        },
+        commit: (node, patch, sceneApi) => {
+            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);
+            if (connectedResize) {
+                commitCabinetResize(connectedResize.module, connectedResize.patch, sceneApi);
+            }
+        },
         visible: (node, sceneApi) => !isCabinetModule(node) || cabinetModuleSideOpen(node, side, sceneApi),
         placement: {
             position: (node) => [
@@ -580,23 +889,439 @@ function cabinetWidthHandle(side) {
         },
     };
 }
+function cabinetDepthResizePatch(node, depth) {
+    return {
+        depth,
+        position: [node.position[0], node.position[1], node.position[2] + (depth - node.depth) / 2],
+    };
+}
+function snapCabinetDepth(node, requestedDepth, sceneApi) {
+    if (!isCabinetModule(node))
+        return requestedDepth;
+    let snappedDepth = requestedDepth;
+    let closestDistance = Number.POSITIVE_INFINITY;
+    for (const side of ['left', 'right']) {
+        const connected = cabinetWidthConnectedNeighbor(node, side, sceneApi);
+        if (!connected || isCabinetWidthFiller(connected))
+            continue;
+        const distance = Math.abs(requestedDepth - connected.depth);
+        if (distance <= CABINET_DEPTH_SNAP_THRESHOLD && distance < closestDistance) {
+            snappedDepth = connected.depth;
+            closestDistance = distance;
+        }
+    }
+    return snappedDepth;
+}
 function cabinetDepthHandle() {
     return {
         kind: 'linear-resize',
         axis: 'z',
         anchor: 'min',
         min: MIN_CABINET_DEPTH,
+        max: (node) => cabinetResizeUpperBound(node.depth, MAX_CABINET_DEPTH),
         currentValue: (node) => node.depth,
-        apply: (node, depth) => ({
-            depth,
-            position: [node.position[0], node.position[1], node.position[2] + (depth - node.depth) / 2],
-        }),
+        apply: cabinetDepthResizePatch,
+        magneticSnap: snapCabinetDepth,
+        previewOverrides: (node, _depth, sceneApi) => {
+            const parentRunOverride = parentRunGeometryPreviewOverride(node, sceneApi);
+            return parentRunOverride ? [parentRunOverride] : [];
+        },
         commit: commitCabinetResize,
         placement: {
             position: (node) => [0, cabinetTotalHeight(node) / 2, node.depth / 2 + SIDE_HANDLE_OFFSET],
         },
     };
 }
+function cornerBaseSourceRunId(node) {
+    const value = cabinetMetadataRecord(node.metadata).cabinetCornerDerivedRun;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const role = value.role;
+    const sourceRunId = value.sourceRunId;
+    return role === 'base-leg' && typeof sourceRunId === 'string' ? sourceRunId : null;
+}
+function connectedBaseRuns(node, sceneApi) {
+    const runs = new Map();
+    for (const candidate of Object.values(sceneApi.nodes())) {
+        if (isCabinetRun(candidate) && candidate.runTier === 'base') {
+            runs.set(candidate.id, candidate);
+        }
+    }
+    runs.set(node.id, node);
+    const neighbors = new Map();
+    const connect = (a, b) => {
+        const aNeighbors = neighbors.get(a) ?? new Set();
+        const bNeighbors = neighbors.get(b) ?? new Set();
+        aNeighbors.add(b);
+        bNeighbors.add(a);
+        neighbors.set(a, aNeighbors);
+        neighbors.set(b, bNeighbors);
+    };
+    for (const run of runs.values()) {
+        const sourceRunId = cornerBaseSourceRunId(run);
+        if (sourceRunId && runs.has(sourceRunId))
+            connect(sourceRunId, run.id);
+    }
+    const connected = [];
+    const pending = [node.id];
+    const visited = new Set();
+    while (pending.length > 0) {
+        const id = pending.shift();
+        if (visited.has(id))
+            continue;
+        visited.add(id);
+        const run = runs.get(id);
+        if (run)
+            connected.push(run);
+        for (const neighbor of neighbors.get(id) ?? [])
+            pending.push(neighbor);
+    }
+    return connected;
+}
+function cabinetRunFrontCenter(run, sceneApi) {
+    const modules = cabinetModulesForRun(run, sceneApi.nodes());
+    if (modules.length === 0) {
+        return [0, cabinetTotalHeight(run) / 2, run.depth / 2 + SIDE_HANDLE_OFFSET];
+    }
+    const minX = Math.min(...modules.map((module) => module.position[0] - module.width / 2));
+    const maxX = Math.max(...modules.map((module) => module.position[0] + module.width / 2));
+    const maxZ = Math.max(...modules.map((module) => module.position[2] + module.depth / 2));
+    return [(minX + maxX) / 2, cabinetTotalHeight(run) / 2, maxZ + SIDE_HANDLE_OFFSET];
+}
+function cabinetRunPointInSelectedFrame(selected, target, point, sceneApi) {
+    const nodes = sceneApi.nodes();
+    const selectedWorld = cabinetDuplicateWorldPose(selected, nodes);
+    const targetWorld = cabinetDuplicateWorldPose(target, nodes);
+    if (!selectedWorld || !targetWorld)
+        return [point[0], point[1], point[2]];
+    const worldPoint = composeCabinetDuplicatePose(targetWorld.position, targetWorld.rotation, point, 0).position;
+    const dx = worldPoint[0] - selectedWorld.position[0];
+    const dz = worldPoint[2] - selectedWorld.position[2];
+    const cos = Math.cos(selectedWorld.rotation);
+    const sin = Math.sin(selectedWorld.rotation);
+    return [cos * dx - sin * dz, worldPoint[1] - selectedWorld.position[1], sin * dx + cos * dz];
+}
+function cabinetRootRun(node, sceneApi) {
+    let current = node;
+    let root = isCabinetRun(current) ? current : null;
+    const visited = new Set();
+    while (current.parentId && !visited.has(current.parentId)) {
+        visited.add(current.parentId);
+        const parent = sceneApi.get(current.parentId);
+        if (!isCabinetRun(parent) && !isCabinetModule(parent))
+            break;
+        current = parent;
+        if (isCabinetRun(current))
+            root = current;
+    }
+    return root;
+}
+function cabinetWallTargets(node, sceneApi) {
+    const root = cabinetRootRun(node, sceneApi);
+    if (!root)
+        return [];
+    const targets = [];
+    const visited = new Set();
+    const visit = (current) => {
+        if (visited.has(current.id))
+            return;
+        visited.add(current.id);
+        if (isCabinetRun(current) && current.runTier === 'wall') {
+            targets.push(current);
+            return;
+        }
+        const parent = current.parentId ? sceneApi.get(current.parentId) : undefined;
+        if (isCabinetModule(current) && isCabinetModule(parent)) {
+            if (!isHoodOnlyCabinet(current))
+                targets.push(current);
+            return;
+        }
+        for (const childId of current.children ?? []) {
+            const child = sceneApi.get(childId);
+            if (isCabinetRun(child) || isCabinetModule(child))
+                visit(child);
+        }
+    };
+    visit(root);
+    return targets;
+}
+function cabinetWallDepthPreview(targets, depth, sceneApi, adjustCornerWidths, widthMode, cornerIndex) {
+    const overrides = new Map();
+    const liveTargets = targets.map((target) => sceneApi.get(target.id) ?? target);
+    const depthDelta = depth - (liveTargets[0]?.depth ?? depth);
+    for (const live of liveTargets) {
+        const nextDepth = live.depth + depthDelta;
+        if (isCabinetRun(live)) {
+            overrides.set(live.id, { depth: nextDepth });
+            for (const [id, patch] of depthDeltaRunOverrides(live, sceneApi.nodes(), depthDelta)) {
+                overrides.set(id, { ...(overrides.get(id) ?? {}), ...patch });
+            }
+            continue;
+        }
+        overrides.set(live.id, cabinetDepthResizePatch(live, nextDepth));
+    }
+    if (adjustCornerWidths) {
+        for (const [id, patch] of wallCornerWidthOverridesForDepthTargets({
+            cornerIndex,
+            depth,
+            nodes: sceneApi.nodes(),
+            targets: liveTargets,
+            widthMode,
+        })) {
+            const existing = overrides.get(id);
+            const cornerPatch = patch;
+            const merged = { ...(existing ?? {}), ...cornerPatch };
+            if (existing?.position && cornerPatch.position) {
+                merged.position = [cornerPatch.position[0], cornerPatch.position[1], existing.position[2]];
+            }
+            overrides.set(id, merged);
+        }
+    }
+    return [...overrides];
+}
+function commitCabinetWallDepth(targets, depth, sceneApi, adjustCornerWidths, widthMode, cornerIndex) {
+    const preview = cabinetWallDepthPreview(targets, depth, sceneApi, adjustCornerWidths, widthMode, cornerIndex);
+    for (const [id, patch] of preview) {
+        sceneApi.update(id, patch);
+    }
+    const bumpedRuns = new Set();
+    for (const [id] of preview) {
+        const live = sceneApi.get(id);
+        if (isCabinetRun(live)) {
+            if (!bumpedRuns.has(live.id)) {
+                bumpedRuns.add(live.id);
+                bumpCabinetRunLayoutRevision(sceneApi, live);
+            }
+            continue;
+        }
+        const parent = live?.parentId ? sceneApi.get(live.parentId) : undefined;
+        if (isCabinetRun(parent) && !bumpedRuns.has(parent.id)) {
+            bumpedRuns.add(parent.id);
+            bumpCabinetRunLayoutRevision(sceneApi, parent);
+        }
+        else if (isCabinetModule(parent)) {
+            sceneApi.markDirty(parent.id);
+        }
+    }
+}
+function cabinetWallDepthBounds(targets, sceneApi, adjustCornerWidths, widthMode, cornerIndex) {
+    const liveTargets = targets.map((target) => sceneApi.get(target.id) ?? target);
+    const currentDepth = liveTargets[0]?.depth ?? MIN_CABINET_DEPTH;
+    const sharedBounds = sharedDepthBounds(currentDepth, liveTargets, sceneApi.nodes());
+    let min = sharedBounds.min;
+    let max = sharedBounds.max;
+    if (!adjustCornerWidths)
+        return { min, max };
+    const baselineAdjustments = new Map(wallCornerWidthOverridesForDepthTargets({
+        clampWidths: false,
+        cornerIndex,
+        depth: currentDepth,
+        nodes: sceneApi.nodes(),
+        targets: liveTargets,
+        widthMode,
+    }));
+    const unitAdjustments = wallCornerWidthOverridesForDepthTargets({
+        clampWidths: false,
+        cornerIndex,
+        depth: currentDepth + 1,
+        nodes: sceneApi.nodes(),
+        targets: liveTargets,
+        widthMode,
+    });
+    for (const [id, patch] of unitAdjustments) {
+        const cabinetPatch = patch;
+        if (typeof cabinetPatch.width !== 'number')
+            continue;
+        const node = sceneApi.get(id);
+        if (!isCabinetModule(node))
+            continue;
+        const baselinePatch = baselineAdjustments.get(id);
+        const baselineWidth = typeof baselinePatch?.width === 'number' ? baselinePatch.width : node.width;
+        const factor = cabinetPatch.width - baselineWidth;
+        if (Math.abs(factor) <= CABINET_ADJACENCY_EPSILON)
+            continue;
+        const minWidth = node.name === 'Wall Bridge Filler'
+            ? 0
+            : node.name?.includes('Filler')
+                ? 0.05
+                : MIN_CABINET_WIDTH;
+        const maxWidth = cabinetResizeUpperBound(baselineWidth, MAX_CABINET_WIDTH);
+        const firstDepth = currentDepth + (minWidth - baselineWidth) / factor;
+        const secondDepth = currentDepth + (maxWidth - baselineWidth) / factor;
+        min = Math.max(min, Math.min(firstDepth, secondDepth));
+        max = Math.min(max, Math.max(firstDepth, secondDepth));
+    }
+    return {
+        min: Math.min(currentDepth, min),
+        max: Math.max(currentDepth, max),
+    };
+}
+function cabinetWallGroupDepthHandles(selected, sceneApi) {
+    const targets = cabinetWallTargets(selected, sceneApi);
+    if (targets.length < 2)
+        return [];
+    const cornerIndex = buildWallCornerDepthIndex(sceneApi.nodes());
+    const groups = [];
+    for (const target of targets) {
+        const rotation = cabinetDuplicateWorldPose(target, sceneApi.nodes())?.rotation ?? target.rotation;
+        const group = groups.find((candidate) => Math.abs(Math.atan2(Math.sin(rotation - candidate.rotation), Math.cos(rotation - candidate.rotation))) < 1e-3);
+        if (group)
+            group.targets.push(target);
+        else
+            groups.push({ rotation, targets: [target] });
+    }
+    const selectedRotation = cabinetDuplicateWorldPose(selected, sceneApi.nodes())?.rotation ?? 0;
+    return groups.map((group) => {
+        const representative = group.targets[0];
+        const relativeRotation = group.rotation - selectedRotation;
+        const frontX = Math.sin(relativeRotation);
+        const frontZ = Math.cos(relativeRotation);
+        const axis = Math.abs(frontX) > Math.abs(frontZ) ? 'x' : 'z';
+        const positive = axis === 'x' ? frontX >= 0 : frontZ >= 0;
+        const adjustCornerWidths = true;
+        const widthMode = Math.abs(frontX) < 1e-3 && frontZ > 0 ? 'corner-pair' : 'bridge';
+        const depthBounds = () => cabinetWallDepthBounds(group.targets, sceneApi, adjustCornerWidths, widthMode, cornerIndex);
+        const clampedDepth = (requestedDepth, liveSceneApi) => {
+            const bounds = cabinetWallDepthBounds(group.targets, liveSceneApi, adjustCornerWidths, widthMode, cornerIndex);
+            return Math.min(bounds.max, Math.max(bounds.min, requestedDepth));
+        };
+        return {
+            kind: 'linear-resize',
+            axis,
+            anchor: positive ? 'min' : 'max',
+            min: () => depthBounds().min,
+            max: () => depthBounds().max,
+            currentValue: () => sceneApi.get(representative.id)?.depth ??
+                representative.depth,
+            overrideTarget: () => representative.id,
+            apply: (_node, depth) => ({ depth }),
+            previewOverrides: (_node, depth, liveSceneApi) => cabinetWallDepthPreview(group.targets, clampedDepth(depth, liveSceneApi), liveSceneApi, adjustCornerWidths, widthMode, cornerIndex),
+            commit: (_node, patch, liveSceneApi) => {
+                if (typeof patch.depth === 'number') {
+                    commitCabinetWallDepth(group.targets, clampedDepth(patch.depth, liveSceneApi), liveSceneApi, adjustCornerWidths, widthMode, cornerIndex);
+                }
+            },
+            placement: {
+                position: (node, liveSceneApi) => {
+                    const points = group.targets.map((target) => {
+                        const liveTarget = liveSceneApi.get(target.id) ?? target;
+                        const point = isCabinetRun(liveTarget)
+                            ? cabinetRunFrontCenter(liveTarget, liveSceneApi)
+                            : [
+                                0,
+                                cabinetTotalHeight(liveTarget) / 2,
+                                liveTarget.depth / 2 + SIDE_HANDLE_OFFSET,
+                            ];
+                        return cabinetRunPointInSelectedFrame(node, liveTarget, point, liveSceneApi);
+                    });
+                    return [
+                        points.reduce((sum, point) => sum + point[0], 0) / points.length,
+                        points.reduce((sum, point) => sum + point[1], 0) / points.length,
+                        points.reduce((sum, point) => sum + point[2], 0) / points.length,
+                    ];
+                },
+                rotationY: () => (axis === 'x' ? relativeRotation - Math.PI / 2 : relativeRotation),
+            },
+        };
+    });
+}
+function cabinetConnectedRunDepthHandle(selected, target, sceneApi) {
+    const nodes = sceneApi.nodes();
+    const selectedWorld = cabinetDuplicateWorldPose(selected, nodes);
+    const targetWorld = cabinetDuplicateWorldPose(target, nodes);
+    const relativeRotation = (targetWorld?.rotation ?? 0) - (selectedWorld?.rotation ?? 0);
+    const frontX = Math.sin(relativeRotation);
+    const frontZ = Math.cos(relativeRotation);
+    const axis = Math.abs(frontX) > Math.abs(frontZ) ? 'x' : 'z';
+    const positive = axis === 'x' ? frontX >= 0 : frontZ >= 0;
+    const targetDepthBounds = (liveSceneApi) => {
+        const liveTarget = liveSceneApi.get(target.id) ?? target;
+        const compensatedWidths = [];
+        const derived = cabinetMetadataRecord(liveTarget.metadata).cabinetCornerDerivedRun;
+        if (derived && typeof derived === 'object' && !Array.isArray(derived)) {
+            const role = derived.role;
+            const side = derived.side;
+            const turnSide = derived.turnSide;
+            const sourceModuleId = derived.sourceModuleId;
+            const sourceModule = role === 'base-leg' &&
+                (turnSide === side || (turnSide !== 'left' && turnSide !== 'right')) &&
+                typeof sourceModuleId === 'string'
+                ? liveSceneApi.get(sourceModuleId)
+                : undefined;
+            if (sourceModule?.type === 'cabinet-module') {
+                compensatedWidths.push(sourceModule.width);
+            }
+        }
+        for (const childId of liveTarget.children ?? []) {
+            const child = liveSceneApi.get(childId);
+            if (child?.type !== 'cabinet')
+                continue;
+            const childDerived = cabinetMetadataRecord(child.metadata).cabinetCornerDerivedRun;
+            if (!childDerived || typeof childDerived !== 'object' || Array.isArray(childDerived))
+                continue;
+            if (childDerived.role !== 'base-leg' ||
+                childDerived.sourceRunId !== target.id) {
+                continue;
+            }
+            const connectedModule = cabinetModulesForRun(child, liveSceneApi.nodes()).find((module) => module.name === 'Base Cabinet');
+            if (connectedModule)
+                compensatedWidths.push(connectedModule.width);
+        }
+        const connectedBounds = cabinetConnectedDepthBounds(liveTarget.depth, compensatedWidths);
+        const deltaBounds = sharedDepthBounds(liveTarget.depth, [liveTarget], liveSceneApi.nodes());
+        return {
+            min: Math.max(connectedBounds.min, deltaBounds.min),
+            max: Math.min(connectedBounds.max, deltaBounds.max),
+        };
+    };
+    const clampedDepth = (depth, liveSceneApi) => {
+        const bounds = targetDepthBounds(liveSceneApi);
+        return Math.min(bounds.max, Math.max(bounds.min, depth));
+    };
+    return {
+        kind: 'linear-resize',
+        axis,
+        anchor: positive ? 'min' : 'max',
+        min: (_node, liveSceneApi) => targetDepthBounds(liveSceneApi).min,
+        max: (_node, liveSceneApi) => targetDepthBounds(liveSceneApi).max,
+        currentValue: (node) => node.id === target.id
+            ? node.depth
+            : (sceneApi.get(target.id)?.depth ?? target.depth),
+        overrideTarget: () => target.id,
+        apply: (_node, depth) => ({ depth }),
+        previewOverrides: (_node, depth, liveSceneApi) => {
+            const liveTarget = liveSceneApi.get(target.id) ?? target;
+            const nextDepth = clampedDepth(depth, liveSceneApi);
+            const moduleOverrides = depthDeltaRunOverrides(liveTarget, liveSceneApi.nodes(), nextDepth - liveTarget.depth);
+            const sourceOverrides = cornerSourceWidthOverridesForDerivedDepth(liveTarget, liveSceneApi.nodes(), nextDepth);
+            return previewCornerRunsFromRunSources({
+                baseLayout: 'width-only',
+                initialOverrides: [...moduleOverrides, ...sourceOverrides],
+                run: { ...liveTarget, depth: nextDepth },
+                sceneApi: liveSceneApi,
+            });
+        },
+        commit: (_node, patch, liveSceneApi) => {
+            if (typeof patch.depth !== 'number')
+                return;
+            const liveTarget = liveSceneApi.get(target.id) ?? target;
+            const nextDepth = clampedDepth(patch.depth, liveSceneApi);
+            for (const [id, sourcePatch] of cornerSourceWidthOverridesForDerivedDepth(liveTarget, liveSceneApi.nodes(), nextDepth)) {
+                liveSceneApi.update(id, sourcePatch);
+            }
+            commitRunDepthDelta(liveTarget, nextDepth, liveSceneApi, {
+                cornerSync: 'width-only',
+            });
+        },
+        placement: {
+            position: (node, liveSceneApi) => {
+                const liveTarget = liveSceneApi.get(target.id) ?? target;
+                return cabinetRunPointInSelectedFrame(node, liveTarget, cabinetRunFrontCenter(liveTarget, liveSceneApi), liveSceneApi);
+            },
+            rotationY: () => (axis === 'x' ? relativeRotation - Math.PI / 2 : relativeRotation),
+        },
+    };
+}
 function cabinetHeightHandle() {
     return {
         kind: 'linear-resize',
@@ -655,9 +1380,18 @@ function cabinetRotateHandle() {
         },
     };
 }
-function cabinetHandles(node) {
+function cabinetHandles(node, sceneApi) {
     if ((node.children ?? []).length > 0) {
-        return [cabinetRotateHandle()];
+        const connectedRuns = sceneApi && node.runTier === 'base' ? connectedBaseRuns(node, sceneApi) : [];
+        const depthHandles = sceneApi
+            ? connectedRuns.map((run) => cabinetConnectedRunDepthHandle(node, run, sceneApi))
+            : [];
+        const wallDepthHandles = sceneApi ? cabinetWallGroupDepthHandles(node, sceneApi) : [];
+        return [
+            ...depthHandles,
+            ...wallDepthHandles,
+            cabinetRotateHandle(),
+        ];
     }
     const handles = [
         cabinetDepthHandle(),
@@ -673,16 +1407,21 @@ function isHoodOnlyCabinet(node) {
     const stack = stackForCabinet(node);
     return stack.length > 0 && stack.every((compartment) => isHoodCompartmentType(compartment.type));
 }
-function cabinetModuleHandles(node) {
-    const handles = [
-        cabinetWidthHandle('left'),
-        cabinetWidthHandle('right'),
-        cabinetRotateHandle(),
+function cabinetModuleHandles() {
+    return [
+        {
+            ...cabinetWidthHandle('left'),
+            visible: (node, sceneApi) => !isCabinetWidthFiller(node) && !cabinetModuleSideHasCornerFiller(node, 'left', sceneApi),
+        },
+        {
+            ...cabinetWidthHandle('right'),
+            visible: (node, sceneApi) => !isCabinetWidthFiller(node) && !cabinetModuleSideHasCornerFiller(node, 'right', sceneApi),
+        },
+        {
+            ...cabinetDepthHandle(),
+            visible: (node) => !isCabinetWidthFiller(node),
+        },
     ];
-    if (!isHoodOnlyCabinet(node)) {
-        handles.splice(1, 0, cabinetDepthHandle(), cabinetHeightHandle());
-    }
-    return handles;
 }
 export const cabinetDefinition = {
     kind: 'cabinet',
@@ -701,8 +1440,8 @@ export const cabinetDefinition = {
         rotation: 0,
         runTier: 'base',
         children: [],
-        width: 0.6,
-        depth: 0.58,
+        width: 0.5,
+        depth: 0.5,
         carcassHeight: 0.72,
         operationState: 0,
         plinthHeight: 0.1,
@@ -814,6 +1553,7 @@ export const cabinetDefinition = {
     floorplan: buildCabinetFloorplan,
     floorplanSiblingOverrides: cabinetFloorplanSiblingOverrides,
     floorplanAffectedIds: cabinetFloorplanAffectedIds,
+    quickActionNodeScope: 'level',
     quickActions: cabinetQuickActions,
     // Corner-derived leg runs hide their own tree rows; their modules are
     // flattened into the source run's hierarchy.
@@ -876,8 +1616,8 @@ export const cabinetModuleDefinition = {
         rotation: 0,
         children: [],
         cabinetType: 'base',
-        width: 0.6,
-        depth: 0.58,
+        width: 0.5,
+        depth: 0.5,
         carcassHeight: 0.72,
         operationState: 0,
         plinthHeight: 0,
@@ -932,13 +1672,9 @@ export const cabinetModuleDefinition = {
             },
             collides: true,
         },
-        dragBounds: (node) => {
-            const n = node;
-            const height = cabinetTotalHeight(n);
-            return {
-                size: [n.width, height, n.depth],
-                center: [0, height / 2, 0],
-            };
+        dragBounds: (node, nodes) => {
+            const bounds = cabinetLocalBounds(node, nodes);
+            return { size: bounds.size, center: bounds.center };
         },
         paint: cabinetPaint,
         sceneAction: cabinetSceneAction,
@@ -983,6 +1719,7 @@ export const cabinetModuleDefinition = {
     // 2D ↔ 3D parity: module position is run-local, so the generic overlay's
     // plan-space translate would corrupt it on any rotated / offset run.
     floorplanMoveTarget: cabinetModuleFloorplanMoveTarget,
+    quickActionNodeScope: 'level',
     quickActions: cabinetQuickActions,
     tree: {
         label: cabinetTreeLabel,