@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/cabinet/definition.js

@@ -1,2112 +1,6 @@
-import { CABINET_METRIC_DEFAULTS, cabinetSlots, findLevelAncestorId, selectionProxyIdFromMetadata, } from '@pascal-app/core';
-import { findWallOpeningConflicts } from '../shared/wall-opening-clearance.js';
-import { bakeCabinetAnimationClip } from './animation.js';
-import { buildCabinetFloorplan, buildCabinetModuleFloorplan } from './floorplan.js';
-import { cabinetModuleFloorplanMoveTarget } from './floorplan-move.js';
-import { cabinetFloorplanSiblingOverrides } from './floorplan-overrides.js';
-import { buildCabinetGeometry } from './geometry.js';
-import { withCabinetHostedChildren } from './hosted-resize.js';
-import { toggleCabinetOperationState } from './interaction.js';
-import { cabinetModuleParentFrame } from './move-frame.js';
-import { cabinetPaint } from './paint.js';
-import { cabinetModuleUsesFixedApplianceWidth } from './panel-visibility.js';
-import { cabinetModuleParametrics, cabinetParametrics } from './parametrics.js';
-import { cabinetPlacementNotice } from './placement-notice.js';
-import { resolveCabinetGridPosition } from './placement-snap.js';
-import useCabinetPlacementType from './placement-type.js';
-import { metadataForSelectedWidth, metadataWithPresetWidthDebt } from './preset-width-debt.js';
-import { cabinetQuickActions } from './quick-actions.js';
-import { cabinetConnectedDepthBounds, cabinetResizeUpperBound, MAX_CABINET_DEPTH, MAX_CABINET_WIDTH, MIN_CABINET_DEPTH, MIN_CABINET_WIDTH, } from './resize-limits.js';
-import { moduleSideOpen, reflowRunModules as reflowCabinetRunModules, runWallConstraints, sortRunModules, } from './run-layout.js';
-import { backAlignedRunDepthOverrides, backAlignZ, buildWallCornerDepthIndex, bumpCabinetRunLayoutRevision, cabinetMetadataRecord, cabinetModulesForRun, cabinetModuleTotalHeight, totalCabinetHeight as cabinetTotalHeight, cornerSourceWidthOverridesForDerivedDepth, nestedCornerRunPositionOverrides, previewCornerRunsFromRunSources, resolveCabinetType, runModuleBaseY, syncCornerRunsFromRunSources, syncCornerRunsFromSourceModule, wallChildOf, wallCornerWidthOverridesForDepthTargets, } from './run-ops.js';
-import { cabinetSceneAction } from './scene-action.js';
-import { CabinetModuleNode, CabinetNode } from './schema.js';
-import { backAnchoredModuleZ, isHoodCompartmentType, minCabinetCarcassHeightForStack, stackForCabinet, } from './stack.js';
-import { cabinetModuleSurfaceProvider, cabinetSurfaceProvider } from './surfaces.js';
-import { cabinetFloorplanAffectedIds, cabinetTreeChildIds, cabinetTreeHidden, cabinetTreeLabel, } from './tree-structure.js';
-import { findClosestCabinetWallInPlan, resolveCabinetModuleWallSnapLocal, resolveCabinetRunWallSnap, resolveCabinetWallFaceOffset, } from './wall-snap.js';
-function isCabinetDuplicableNode(node) {
-    return ((node?.type === 'cabinet' || node?.type === 'cabinet-module') &&
-        Array.isArray(node.position) &&
-        typeof node.rotation === 'number');
-}
-function stripCabinetDuplicateMetadata(metadata) {
-    const { cabinetCornerDerivedRun: _derived, cabinetCornerSourceLink: _source, nodeSelectionProxyId: _proxy, ...rest } = cabinetMetadataRecord(metadata);
-    return rest;
-}
-function cleanCabinetDuplicateNode(node) {
-    return {
-        ...node,
-        metadata: stripCabinetDuplicateMetadata(node.metadata),
-    };
-}
-function composeCabinetDuplicatePose(parentPosition, parentRotation, childPosition, childRotation) {
-    const cos = Math.cos(parentRotation);
-    const sin = Math.sin(parentRotation);
-    return {
-        position: [
-            parentPosition[0] + childPosition[0] * cos + childPosition[2] * sin,
-            parentPosition[1] + childPosition[1],
-            parentPosition[2] - childPosition[0] * sin + childPosition[2] * cos,
-        ],
-        rotation: parentRotation + childRotation,
-    };
-}
-function cabinetDuplicateWorldPose(node, nodes) {
-    if (!isCabinetDuplicableNode(node))
-        return null;
-    const parent = node.parentId ? nodes[node.parentId] : null;
-    if (isCabinetDuplicableNode(parent)) {
-        const parentPose = cabinetDuplicateWorldPose(parent, nodes);
-        return parentPose
-            ? composeCabinetDuplicatePose(parentPose.position, parentPose.rotation, node.position, node.rotation)
-            : null;
-    }
-    return { position: [...node.position], rotation: node.rotation };
-}
-function prepareCabinetSubtreeClone(args) {
-    const parent = args.root.parentId ? args.nodes[args.root.parentId] : null;
-    const nestedRun = args.root.type === 'cabinet' && isCabinetDuplicableNode(parent);
-    const worldPose = nestedRun ? cabinetDuplicateWorldPose(args.root, args.nodes) : null;
-    const levelId = nestedRun ? findLevelAncestorId(args.rootId, args.nodes) : null;
-    const root = {
-        ...cleanCabinetDuplicateNode(args.root),
-        ...(worldPose ? { position: worldPose.position, rotation: worldPose.rotation } : null),
-        ...(levelId ? { parentId: levelId } : null),
-    };
-    return {
-        root,
-        descendants: args.descendants.map((node) => cleanCabinetDuplicateNode(node)),
-        parentId: levelId ? levelId : undefined,
-    };
-}
-function appendCabinetFloorPlacedFootprints(run, nodes, parentPosition, parentRotation, footprints) {
-    const cos = Math.cos(parentRotation);
-    const sin = Math.sin(parentRotation);
-    const runPosition = [
-        parentPosition[0] + run.position[0] * cos + run.position[2] * sin,
-        parentPosition[1] + run.position[1],
-        parentPosition[2] - run.position[0] * sin + run.position[2] * cos,
-    ];
-    const runRotation = parentRotation + run.rotation;
-    const modules = cabinetModulesForRun(run, nodes);
-    if (modules.length > 0) {
-        const runCos = Math.cos(runRotation);
-        const runSin = Math.sin(runRotation);
-        for (const module of modules) {
-            const modulePosition = [
-                runPosition[0] + module.position[0] * runCos + module.position[2] * runSin,
-                runPosition[1] + module.position[1],
-                runPosition[2] - module.position[0] * runSin + module.position[2] * runCos,
-            ];
-            footprints.push({
-                position: modulePosition,
-                dimensions: [module.width, cabinetModuleTotalHeight(module), module.depth],
-                rotation: [0, runRotation + module.rotation, 0],
-            });
-        }
-    }
-    else {
-        footprints.push({
-            position: runPosition,
-            dimensions: [run.width, cabinetTotalHeight(run), run.depth],
-            rotation: [0, runRotation, 0],
-        });
-    }
-    for (const childId of run.children ?? []) {
-        const child = nodes[childId];
-        if (isCabinetRun(child)) {
-            appendCabinetFloorPlacedFootprints(child, nodes, runPosition, runRotation, footprints);
-        }
-    }
-}
-export function cabinetFloorPlacedFootprints(node, nodes) {
-    if (!nodes) {
-        return [
-            {
-                position: [...node.position],
-                dimensions: [node.width, cabinetTotalHeight(node), node.depth],
-                rotation: [0, node.rotation, 0],
-            },
-        ];
-    }
-    const footprints = [];
-    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;
-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';
-}
-function isCabinetRun(node) {
-    return node?.type === 'cabinet';
-}
-function hasCabinetParentId(node) {
-    const parentId = node.parentId;
-    return (typeof parentId === 'string' &&
-        (parentId.startsWith('cabinet_') || parentId.startsWith('cabinet-module_')));
-}
-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
- * converts through `planToLocal` before and `localToPlan` after), so this
- * resolver works local-in / local-out.
- */
-function resolveCabinetModuleGroupMoveSnap({ candidatePosition, levelId, movingIds, node, nodes, }) {
-    if (node.type !== 'cabinet-module' || !node.parentId)
-        return null;
-    const run = nodes[node.parentId];
-    if (!isCabinetRun(run))
-        return null;
-    const parentLevelId = (levelId ?? run.parentId ?? null);
-    if (!parentLevelId)
-        return null;
-    const position = resolveCabinetModuleWallSnapLocal({
-        candidateLocal: candidatePosition,
-        excludeIds: movingIds,
-        module: node,
-        nodes: nodes,
-        parentLevelId,
-        run,
-    });
-    return position ? { position } : null;
-}
-function cabinetLayoutRevision(metadata) {
-    return cabinetMetadataRecord(metadata).cabinetLayoutRevision ?? null;
-}
-function cabinetAdjacencyRevision(metadata) {
-    return cabinetMetadataRecord(metadata).cabinetAdjacencyRevision ?? null;
-}
-// Margin added to each run's reach when deciding whether two sibling runs can
-// influence each other's countertop join — generous relative to any plausible
-// `countertopOverhang` so a run sliding away still re-keys the neighbor it
-// just un-joined from.
-const CABINET_NEIGHBOR_JOIN_MARGIN = 0.5;
-export function cabinetRunFootprint(run, nodes) {
-    const bounds = cabinetLocalBounds(run, nodes);
-    return {
-        parentId: (run.parentId ?? null),
-        x: run.position[0],
-        z: run.position[2],
-        reach: Math.hypot(bounds.size[0], bounds.size[2]) / 2 +
-            Math.hypot(bounds.center[0], bounds.center[2]) +
-            CABINET_NEIGHBOR_JOIN_MARGIN,
-    };
-}
-/**
- * Re-key sibling cabinet runs whose countertop join could be affected by a
- * run that moved / resized / re-flowed. A run's overhang trims against
- * adjacent sibling runs (`siblingCabinetSpansInRunLocal`), but a neighbor's
- * own `geometryKey` doesn't change when THIS run moves — marking it dirty
- * alone would be swallowed by the geometry system's key-skip cache. Bumping
- * `cabinetAdjacencyRevision` (folded into the run geometryKey) both dirties
- * and re-keys it. History is paused: the counter is derived presentation
- * state, and an undo of the triggering move re-fires the watcher anyway.
- */
-export function bumpCabinetRunsNear(sceneApi, footprints, moverIds) {
-    const nodes = sceneApi.nodes();
-    const targets = new Set();
-    for (const footprint of footprints) {
-        if (!footprint.parentId)
-            continue;
-        const parent = nodes[footprint.parentId];
-        const childIds = parent?.children;
-        if (!Array.isArray(childIds))
-            continue;
-        for (const childId of childIds) {
-            if (moverIds.has(childId) || targets.has(childId))
-                continue;
-            const sibling = nodes[childId];
-            if (!isCabinetRun(sibling))
-                continue;
-            const siblingFootprint = cabinetRunFootprint(sibling, nodes);
-            const distance = Math.hypot(siblingFootprint.x - footprint.x, siblingFootprint.z - footprint.z);
-            if (distance <= siblingFootprint.reach + footprint.reach)
-                targets.add(childId);
-        }
-    }
-    if (targets.size === 0)
-        return;
-    // A mover's own trim also depends on its offset to those neighbors, and
-    // `position` is not in its geometryKey — re-key it alongside them. Movers
-    // with no neighbors in range never reach here, keeping lone-cabinet moves
-    // rebuild-free.
-    for (const id of moverIds) {
-        if (isCabinetRun(nodes[id]))
-            targets.add(id);
-    }
-    sceneApi.pauseHistory();
-    try {
-        for (const id of targets) {
-            const run = sceneApi.get(id);
-            if (!isCabinetRun(run))
-                continue;
-            const metadataRecord = cabinetMetadataRecord(run.metadata);
-            const currentRevision = typeof metadataRecord.cabinetAdjacencyRevision === 'number'
-                ? metadataRecord.cabinetAdjacencyRevision
-                : 0;
-            sceneApi.update(id, {
-                metadata: { ...metadataRecord, cabinetAdjacencyRevision: currentRevision + 1 },
-            });
-            sceneApi.markDirty(id);
-        }
-    }
-    finally {
-        sceneApi.resumeHistory();
-    }
-}
-/** Inputs of a run that can change a NEIGHBOR's countertop join. */
-export function cabinetRunNeighborSignature(run) {
-    return JSON.stringify([
-        run.position[0],
-        run.position[2],
-        run.rotation,
-        run.width,
-        run.depth,
-        run.carcassHeight,
-        run.runTier,
-        run.countertopOverhang,
-        (run.children ?? []).filter((id) => id.startsWith('cabinet_') || id.startsWith('cabinet-module_')),
-        cabinetLayoutRevision(run.metadata),
-    ]);
-}
-function includeCabinetModuleBounds(module, nodes, origin, bounds) {
-    const x = origin[0] + module.position[0];
-    const y = origin[1] + module.position[1];
-    const z = origin[2] + module.position[2];
-    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 + 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 ?? []) {
-        const child = nodes[childId];
-        if (isCabinetModule(child))
-            includeCabinetModuleBounds(child, nodes, [x, y, z], bounds);
-    }
-}
-/**
- * Fold a child cabinet run (an L-corner leg parented to this run) into the
- * parent's local bounds: take the child's own local bounds, rotate its XZ
- * corners by the child's local rotation, and offset by its local position.
- */
-function includeChildRunBounds(child, nodes, bounds) {
-    const childBounds = cabinetLocalBounds(child, nodes);
-    const cos = Math.cos(child.rotation);
-    const sin = Math.sin(child.rotation);
-    for (const [lx, lz] of [
-        [childBounds.minX, childBounds.minZ],
-        [childBounds.maxX, childBounds.minZ],
-        [childBounds.maxX, childBounds.maxZ],
-        [childBounds.minX, childBounds.maxZ],
-    ]) {
-        const x = child.position[0] + lx * cos + lz * sin;
-        const z = child.position[2] - lx * sin + lz * cos;
-        bounds.minX = Math.min(bounds.minX, x);
-        bounds.maxX = Math.max(bounds.maxX, x);
-        bounds.minZ = Math.min(bounds.minZ, z);
-        bounds.maxZ = Math.max(bounds.maxZ, z);
-    }
-    bounds.minY = Math.min(bounds.minY, child.position[1] + childBounds.minY);
-    bounds.maxY = Math.max(bounds.maxY, child.position[1] + childBounds.maxY);
-}
-function cabinetLocalBounds(node, nodes) {
-    const bounds = {
-        minX: -node.width / 2,
-        maxX: node.width / 2,
-        minY: 0,
-        maxY: node.type === 'cabinet-module' ? cabinetModuleTotalHeight(node) : cabinetTotalHeight(node),
-        minZ: -node.depth / 2,
-        maxZ: node.depth / 2,
-    };
-    if (isCabinetRun(node) && nodes) {
-        const modules = cabinetModulesForRun(node, nodes);
-        if (modules.length > 0) {
-            bounds.minX = Number.POSITIVE_INFINITY;
-            bounds.maxX = Number.NEGATIVE_INFINITY;
-            bounds.minY = 0;
-            bounds.maxY = (node.showPlinth ? node.plinthHeight : 0) + node.carcassHeight;
-            bounds.minZ = Number.POSITIVE_INFINITY;
-            bounds.maxZ = Number.NEGATIVE_INFINITY;
-            for (const module of modules) {
-                includeCabinetModuleBounds(module, nodes, [0, 0, 0], bounds);
-            }
-            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') {
-                bounds.minZ -= node.countertopBackOverhang;
-            }
-            if (node.withFinishedBack)
-                bounds.minZ -= node.boardThickness;
-            if (node.barLedge) {
-                const edge = node.barLedge.edge;
-                if (edge === 'back')
-                    bounds.minZ -= node.barLedge.depth;
-                if (edge === 'left')
-                    bounds.minX -= node.barLedge.depth;
-                if (edge === 'right')
-                    bounds.maxX += node.barLedge.depth;
-                bounds.maxY = Math.max(bounds.maxY, node.barLedge.height);
-            }
-        }
-        // L-corner leg runs are cabinet children of the source run — fold them in
-        // so the run's rotate ring / pivot / drag box covers the whole L.
-        for (const childId of node.children ?? []) {
-            const child = nodes[childId];
-            if (isCabinetRun(child))
-                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);
-    return {
-        ...bounds,
-        size: [width, height, depth],
-        center: [
-            (bounds.minX + bounds.maxX) / 2,
-            (bounds.minY + bounds.maxY) / 2,
-            (bounds.minZ + bounds.maxZ) / 2,
-        ],
-    };
-}
-function cabinetPlanBoundsAabb(node, nodes) {
-    const bounds = cabinetLocalBounds(node, nodes);
-    const cos = Math.cos(node.rotation);
-    const sin = Math.sin(node.rotation);
-    let minX = Number.POSITIVE_INFINITY;
-    let maxX = Number.NEGATIVE_INFINITY;
-    let minZ = Number.POSITIVE_INFINITY;
-    let maxZ = Number.NEGATIVE_INFINITY;
-    for (const [lx, lz] of [
-        [bounds.minX, bounds.minZ],
-        [bounds.maxX, bounds.minZ],
-        [bounds.maxX, bounds.maxZ],
-        [bounds.minX, bounds.maxZ],
-    ]) {
-        const x = node.position[0] + lx * cos + lz * sin;
-        const z = node.position[2] - lx * sin + lz * cos;
-        minX = Math.min(minX, x);
-        maxX = Math.max(maxX, x);
-        minZ = Math.min(minZ, z);
-        maxZ = Math.max(maxZ, z);
-    }
-    return { minX, maxX, minZ, maxZ };
-}
-function cabinetModuleSideOpen(module, side, sceneApi) {
-    const parent = module.parentId ? sceneApi.get(module.parentId) : undefined;
-    if (!isCabinetRun(parent))
-        return true;
-    return moduleSideOpen(cabinetModulesForRun(parent, sceneApi.nodes()), module.id, side, CABINET_ADJACENCY_EPSILON);
-}
-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 !== 'standard' ||
-        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);
-    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) => {
-        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) {
-                Object.assign(modulePatch, depthOverrides.get(module.id));
-            }
-            if (syncHeight) {
-                modulePatch.carcassHeight = Math.max(nextRun.carcassHeight, minCabinetCarcassHeightForStack(module));
-            }
-            if (syncPosition) {
-                modulePatch.position = [
-                    modulePatch.position?.[0] ?? module.position[0],
-                    runModuleBaseY(nextRun),
-                    modulePatch.position?.[2] ?? module.position[2],
-                ];
-            }
-            if (Object.keys(modulePatch).length > 0) {
-                sceneApi.update(module.id, modulePatch);
-                const wallChild = wallChildOf(module, sceneApi.nodes());
-                if (wallChild && typeof modulePatch.depth === 'number') {
-                    sceneApi.update(wallChild.id, {
-                        position: [
-                            wallChild.position[0],
-                            wallChild.position[1],
-                            backAlignZ(modulePatch.depth, wallChild.depth),
-                        ],
-                    });
-                }
-            }
-        }
-        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);
-        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;
-    const parentRun = isCabinetRun(parent) ? parent : undefined;
-    if (!parentRun) {
-        sceneApi.update(module.id, patch);
-        const parentModule = isCabinetModule(parent) ? parent : undefined;
-        if (parentModule)
-            sceneApi.markDirty(parentModule.id);
-        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());
-            if (wallChild) {
-                sceneApi.update(wallChild.id, { width: patch.width });
-            }
-        }
-        bumpCabinetRunLayoutRevision(sceneApi, parentRun);
-        syncCornerRunsFromSourceModule({
-            module: sceneApi.get(module.id) ?? module,
-            previousModule,
-            run: sceneApi.get(parentRun.id) ?? parentRun,
-            sceneApi,
-        });
-        return;
-    }
-    const modulePatch = { ...patch };
-    if (typeof patch.depth === 'number') {
-        modulePatch.position = [
-            patch.position?.[0] ?? module.position[0],
-            patch.position?.[1] ?? module.position[1],
-            backAnchoredModuleZ(module.position[2], module.depth, patch.depth),
-        ];
-    }
-    sceneApi.update(module.id, modulePatch);
-    if (resolveCabinetType(module, parentRun) === 'base') {
-        const runPatch = {};
-        if (typeof patch.carcassHeight === 'number') {
-            runPatch.carcassHeight = patch.carcassHeight;
-        }
-        if (Object.keys(runPatch).length > 0) {
-            commitRunResize(parentRun, runPatch, sceneApi);
-        }
-        else {
-            bumpCabinetRunLayoutRevision(sceneApi, parentRun);
-        }
-    }
-    else {
-        bumpCabinetRunLayoutRevision(sceneApi, parentRun);
-    }
-    syncCornerRunsFromSourceModule({
-        module: sceneApi.get(module.id) ?? module,
-        previousModule: module,
-        run: sceneApi.get(parentRun.id) ?? parentRun,
-        sceneApi,
-    });
-    const wallChild = wallChildOf(module, sceneApi.nodes());
-    if (wallChild && typeof modulePatch.depth === 'number') {
-        sceneApi.update(wallChild.id, {
-            position: [
-                wallChild.position[0],
-                wallChild.position[1],
-                backAlignZ(modulePatch.depth, wallChild.depth),
-            ],
-        });
-    }
-}
-function commitCabinetResize(node, patch, sceneApi) {
-    const liveNode = sceneApi.get(node.id) ?? node;
-    if (isCabinetRun(liveNode)) {
-        commitRunResize(liveNode, patch, sceneApi);
-        return;
-    }
-    if (isCabinetModule(liveNode)) {
-        commitModuleResize(liveNode, patch, sceneApi);
-        return;
-    }
-    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 {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: side === 'right' ? 'min' : 'max',
-        min: (node, sceneApi) => {
-            if (!isCabinetModule(node))
-                return MIN_CABINET_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 = 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, 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,
-                position: [
-                    node.position[0] + (sign * (effectiveWidth - node.width)) / 2,
-                    node.position[1],
-                    node.position[2],
-                ],
-            };
-        },
-        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);
-            const connectedResize = connectedCabinetWidthResize(node, side, width - node.width, sceneApi);
-            if (connectedResize) {
-                overrides.push([
-                    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 previewCabinetCornerWidthOverrides(node, overrides, 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;
-            const selectedPatch = isCabinetModule(node) && typeof patch.width === 'number'
-                ? {
-                    ...patch,
-                    metadata: metadataForSelectedWidth(node, patch.width, patch.metadata),
-                }
-                : patch;
-            commitCabinetResize(node, selectedPatch, sceneApi);
-            if (connectedResize) {
-                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),
-        placement: {
-            position: (node) => [
-                sign * (node.width / 2 + SIDE_HANDLE_OFFSET),
-                cabinetTotalHeight(node) / 2,
-                0,
-            ],
-            rotationY: () => (side === 'left' ? Math.PI : 0),
-        },
-    };
-}
-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: 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',
-        axis: 'y',
-        anchor: 'min',
-        min: MIN_CABINET_CARCASS_HEIGHT,
-        currentValue: (node) => node.carcassHeight,
-        apply: (_node, carcassHeight) => ({ carcassHeight }),
-        commit: commitCabinetResize,
-        placement: {
-            position: (node, sceneApi) => [
-                0,
-                cabinetLocalBounds(node, sceneApi.nodes()).maxY + HEIGHT_HANDLE_OFFSET,
-                0,
-            ],
-        },
-    };
-}
-function cabinetRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        apply: (initial, delta, sceneApi) => {
-            const rotation = (initial.rotation ?? 0) - delta;
-            const bounds = cabinetLocalBounds(initial, sceneApi.nodes());
-            const [centerX, , centerZ] = bounds.center;
-            const previousRotation = initial.rotation ?? 0;
-            const previousCos = Math.cos(previousRotation);
-            const previousSin = Math.sin(previousRotation);
-            const nextCos = Math.cos(rotation);
-            const nextSin = Math.sin(rotation);
-            const pivotWorldX = initial.position[0] + centerX * previousCos + centerZ * previousSin;
-            const pivotWorldZ = initial.position[2] - centerX * previousSin + centerZ * previousCos;
-            return {
-                rotation,
-                position: [
-                    pivotWorldX - centerX * nextCos - centerZ * nextSin,
-                    initial.position[1],
-                    pivotWorldZ + centerX * nextSin - centerZ * nextCos,
-                ],
-            };
-        },
-        placement: {
-            position: (node, sceneApi) => {
-                const bounds = cabinetLocalBounds(node, sceneApi.nodes());
-                return [bounds.maxX, bounds.center[1], bounds.maxZ + ROTATE_CORNER_OFFSET];
-            },
-            rotationY: () => -Math.PI / 4,
-        },
-        rotationCenter: (node, sceneApi) => cabinetLocalBounds(node, sceneApi.nodes()).center,
-        decoration: {
-            kind: 'ring',
-            radius: (node, sceneApi) => {
-                const bounds = cabinetLocalBounds(node, sceneApi.nodes());
-                return Math.hypot(bounds.size[0] / 2, bounds.size[2] / 2) + ROTATE_RING_OFFSET;
-            },
-            y: (node) => cabinetTotalHeight(node) / 2,
-            center: (node, sceneApi) => cabinetLocalBounds(node, sceneApi.nodes()).center,
-        },
-    };
-}
-function cabinetHandles(node, sceneApi) {
-    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))
-            : [];
-        const wallDepthHandles = sceneApi ? cabinetWallGroupDepthHandles(node, sceneApi) : [];
-        return [
-            ...depthHandles,
-            ...wallDepthHandles,
-            cabinetRotateHandle(),
-        ];
-    }
-    const handles = [
-        cabinetDepthHandle(),
-        cabinetHeightHandle(),
-        cabinetRotateHandle(),
-    ];
-    if (structuralChildren.length === 0) {
-        handles.unshift(cabinetWidthHandle('left'), cabinetWidthHandle('right'));
-    }
-    return handles;
-}
-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) &&
-                !cabinetModuleUsesFixedApplianceWidth(node) &&
-                !cabinetModuleSideHasCornerFiller(node, 'left', sceneApi),
-        },
-        {
-            ...cabinetWidthHandle('right'),
-            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: 8,
-    schema: CabinetNode,
-    category: 'furnish',
-    surfaceRole: 'joinery',
-    snapProfile: 'item',
-    facingIndicator: true,
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        position: [0, 0, 0],
-        rotation: 0,
-        runTier: 'base',
-        children: [],
-        width: 0.5,
-        depth: CABINET_METRIC_DEFAULTS.depth,
-        carcassHeight: CABINET_METRIC_DEFAULTS.carcassHeight,
-        operationState: 0,
-        plinthHeight: CABINET_METRIC_DEFAULTS.plinthHeight,
-        toeKickDepth: 0.075,
-        boardThickness: 0.018,
-        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',
-        withBottomPanel: true,
-        showPlinth: true,
-        withCountertop: true,
-        // material / materialPreset left undefined — paint mode writes slot refs.
-    }),
-    capabilities: {
-        reveal: { phase: 'furnishing', style: 'drop', height: 0.3 },
-        revealOnEdit: ['width', 'depth', 'carcassHeight', 'plinthHeight'],
-        surfacePlacement: 'floor-only',
-        selectable: { hitVolume: 'bbox' },
-        movable: {
-            axes: ['x', 'z'],
-            directDrag: true,
-            gridSnap: true,
-            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,
-        },
-        rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] },
-        duplicable: { subtree: true, prepareSubtreeClone: prepareCabinetSubtreeClone },
-        deletable: true,
-        surfaces: {
-            hosting: cabinetSurfaceProvider,
-            top: {
-                height: (node, context) => cabinetLocalBounds(node, context.nodes).maxY,
-            },
-        },
-        floorPlaced: {
-            applies: (node) => !hasCabinetParentId(node),
-            footprints: (node, ctx) => cabinetFloorPlacedFootprints(node, ctx?.nodes),
-            collides: true,
-        },
-        alignmentFootprint: (node, nodes) => {
-            const n = node;
-            return { shape: 'aabb', ...cabinetPlanBoundsAabb(n, nodes) };
-        },
-        dragBounds: (node, nodes) => {
-            const bounds = cabinetLocalBounds(node, nodes);
-            return { size: bounds.size, center: bounds.center };
-        },
-        paint: cabinetPaint,
-        sceneAction: cabinetSceneAction,
-        slots: () => cabinetSlots(),
-    },
-    // Dirty-cascade: a dirtied run re-marks its hosted modules so their
-    // composite geometry re-flows with the run (see `cascadeDirty`).
-    relations: {
-        hosts: ['cabinet', 'cabinet-module', 'item', 'procedural-item'],
-    },
-    parametrics: cabinetParametrics,
-    handles: (node, sceneApi) => cabinetHandles(node, sceneApi).map(withCabinetHostedChildren),
-    placementNotice: cabinetPlacementNotice,
-    geometry: buildCabinetGeometry,
-    exportAnimation: ({ node, object }) => bakeCabinetAnimationClip(node, object),
-    system: {
-        module: () => import('./system.js'),
-        priority: 2,
-    },
-    // `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,
-        n.carcassHeight,
-        n.runTier,
-        n.plinthHeight,
-        n.toeKickDepth,
-        n.boardThickness,
-        n.countertopThickness,
-        n.countertopOverhang,
-        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,
-        n.withBottomPanel,
-        n.showPlinth,
-        n.withCountertop,
-        JSON.stringify(n.material ?? null),
-        JSON.stringify(n.materialPreset ?? null),
-        JSON.stringify(n.slots ?? null),
-        JSON.stringify(cabinetLayoutRevision(n.metadata)),
-        // Bumped when a sibling run moves/resizes nearby, so the countertop
-        // 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 ?? []).filter((id) => id.startsWith('cabinet_') || id.startsWith('cabinet-module_'))),
-        JSON.stringify(n.stack ?? null),
-    ]),
-    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.
-    tree: {
-        label: cabinetTreeLabel,
-        hidden: cabinetTreeHidden,
-        childIds: cabinetTreeChildIds,
-    },
-    // E operates the run: every child module's doors/drawers swing together.
-    keyboardActions: {
-        e: {
-            appliesTo: (node) => node.type === 'cabinet',
-            run: (node) => toggleCabinetOperationState(node.id),
-        },
-    },
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Click', label: 'Place cabinet' },
-        {
-            key: 'I',
-            label: 'Placement type',
-            chip: {
-                subscribe: (onChange) => useCabinetPlacementType.subscribe(onChange),
-                value: () => useCabinetPlacementType.getState().type,
-                cycle: () => void useCabinetPlacementType.getState().cycleType(),
-                labels: { cabinet: 'Type: Cabinet', island: 'Type: Island' },
-                icons: { cabinet: 'lucide:rectangle-horizontal', island: 'lucide:table-2' },
-                tooltip: 'Placement type — click or press I to toggle',
-            },
-        },
-        { key: 'Alt', label: 'Force place' },
-        { key: 'R / T', label: 'Rotate' },
-        { key: 'Esc', label: 'Cancel run / exit' },
-    ],
-    presentation: {
-        label: 'Modular Cabinet',
-        description: 'A configurable parametric base cabinet.',
-        icon: { kind: 'url', src: '/icons/item.webp' },
-        paletteSection: 'furnish',
-        paletteOrder: 34,
-    },
-    mcp: {
-        description: 'A configurable parametric base cabinet with plinth, carcass, front panels, optional countertop, and editable dimensions.',
-    },
-};
-export const cabinetModuleDefinition = {
-    kind: 'cabinet-module',
-    schemaVersion: 5,
-    schema: CabinetModuleNode,
-    category: 'furnish',
-    surfaceRole: 'joinery',
-    snapProfile: 'item',
-    facingIndicator: true,
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        position: [0, 0, 0],
-        rotation: 0,
-        children: [],
-        cabinetType: 'base',
-        width: 0.5,
-        depth: CABINET_METRIC_DEFAULTS.depth,
-        carcassHeight: CABINET_METRIC_DEFAULTS.carcassHeight,
-        operationState: 0,
-        plinthHeight: 0,
-        toeKickDepth: 0.075,
-        boardThickness: 0.018,
-        countertopThickness: 0,
-        countertopOverhang: 0.02,
-        countertopBackOverhang: 0,
-        withFinishedBack: false,
-        frontThickness: 0.018,
-        frontGap: 0.003,
-        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',
-        withBottomPanel: true,
-        showPlinth: false,
-        withCountertop: false,
-        // material / materialPreset left undefined — paint mode writes slot refs.
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        surfaces: { hosting: cabinetModuleSurfaceProvider },
-        movable: {
-            axes: ['x', 'z'],
-            directDrag: true,
-            gridSnap: true,
-            parentFrame: cabinetModuleParentFrame,
-            groupMoveSnapPose: resolveCabinetModuleGroupMoveSnap,
-            override: ({ node }) => selectionProxyIdFromMetadata(node.metadata)
-                ? { axes: [], gridSnap: false }
-                : null,
-        },
-        rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] },
-        duplicable: { subtree: true, prepareSubtreeClone: prepareCabinetSubtreeClone },
-        deletable: true,
-        floorPlaced: {
-            applies: (node) => !hasCabinetParentId(node),
-            footprint: (node) => {
-                const n = node;
-                return {
-                    dimensions: [n.width, cabinetModuleTotalHeight(n), n.depth],
-                    rotation: [0, n.rotation, 0],
-                };
-            },
-            collides: true,
-        },
-        dragBounds: (node, nodes) => {
-            const bounds = cabinetLocalBounds(node, nodes);
-            return { size: bounds.size, center: bounds.center };
-        },
-        paint: cabinetPaint,
-        sceneAction: cabinetSceneAction,
-        slots: () => cabinetSlots(),
-    },
-    relations: { hosts: ['cabinet', 'cabinet-module', 'item', 'procedural-item'] },
-    parametrics: cabinetModuleParametrics,
-    handles: () => cabinetModuleHandles().map(withCabinetHostedChildren),
-    placementNotice: cabinetPlacementNotice,
-    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,
-        n.width,
-        n.depth,
-        n.carcassHeight,
-        n.plinthHeight,
-        n.toeKickDepth,
-        n.boardThickness,
-        n.countertopThickness,
-        n.countertopOverhang,
-        n.frontThickness,
-        n.frontGap,
-        n.frontStyle,
-        n.panelReady,
-        n.handleStyle,
-        n.handlePosition,
-        n.frontOverlay,
-        n.withBottomPanel,
-        n.showPlinth,
-        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 ?? []).filter((id) => id.startsWith('cabinet_') || id.startsWith('cabinet-module_'))),
-        JSON.stringify(n.stack ?? null),
-    ]),
-    floorplan: buildCabinetModuleFloorplan,
-    floorplanSiblingOverrides: cabinetFloorplanSiblingOverrides,
-    floorplanAffectedIds: cabinetFloorplanAffectedIds,
-    // 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,
-        childIds: cabinetTreeChildIds,
-    },
-    // Corner-generated modules keep a proxy so grouped move/rotate
-    // affordances can still key off the run, but a direct body click should
-    // stay on the clicked module so added legs / wall cabinets remain
-    // individually selectable.
-    selectionProxy: {
-        bypassDirectPick: (node, proxyTarget) => node.type === 'cabinet-module' && proxyTarget.type === 'cabinet',
-    },
-    // E animates this module's doors/drawers open ↔ closed (hood-only
-    // modules have nothing to operate).
-    keyboardActions: {
-        e: {
-            appliesTo: (node) => node.type === 'cabinet-module' && !isHoodOnlyCabinet(node),
-            run: (node) => toggleCabinetOperationState(node.id),
-        },
-    },
-    presentation: {
-        label: 'Cabinet Module',
-        description: 'An editable module inside a modular cabinet run.',
-        icon: { kind: 'url', src: '/icons/item.webp' },
-        paletteSection: 'furnish',
-        paletteOrder: 35,
-    },
-    mcp: {
-        description: 'A single editable cabinet module inside a modular cabinet run.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { cabinetEditContribution, cabinetModuleEditContribution } from './definition.edit.js';
+import { cabinetModuleRenderDefinition, cabinetRenderDefinition } from './definition.render.js';
+export const cabinetDefinition = composeNodeDefinition(cabinetRenderDefinition, cabinetEditContribution);
+export const cabinetModuleDefinition = composeNodeDefinition(cabinetModuleRenderDefinition, cabinetModuleEditContribution);
+export { bumpCabinetRunsNear, cabinetFloorPlacedFootprints, cabinetRunFootprint, cabinetRunNeighborSignature, } from './definition.render.js';