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

package/dist/cabinet/run-ops.js

@@ -1,8 +1,8 @@
-import { calculateLevelMiters, getWallPlanFootprint, resolveLevelId, selectionProxyIdFromMetadata, } from '@pascal-app/core';
+import { CABINET_METRIC_DEFAULTS, calculateLevelMiters, cloneNodesInto, getWallPlanFootprint, nodeRegistry, resolveLevelId, selectionProxyIdFromMetadata, } from '@pascal-app/core';
 import { MAX_CABINET_WIDTH, MIN_CABINET_WIDTH } from './resize-limits';
-import { moduleMaxX, moduleMinX, planToRunLocal, runLocalToPlan, runLocalXExtent, sideInsertX, sortRunModules, } from './run-layout';
+import { moduleMaxX, moduleMinX, planRunModuleInsertion, planRunModuleWidthEqualization, planToRunLocal, runLocalToPlan, runLocalXExtent, runWallConstraints, sideInsertX, sortRunModules, } from './run-layout';
 import { CabinetModuleNode as CabinetModuleNodeSchema, CabinetNode as CabinetNodeSchema, } from './schema';
-import { backAnchoredModuleZ, hoodCompartmentHeight, newCabinetCompartment, stackForCabinet, } from './stack';
+import { backAnchoredModuleZ, DEFAULT_CEILING_HEIGHT, defaultCabinetStack, hoodCompartmentHeight, newCabinetCompartment, stackForCabinet, } from './stack';
 /**
  * Kind-owned cabinet run mutations, shared by the properties panel, the
  * quick-action menu, and the placement tool. Everything routes through
@@ -13,10 +13,10 @@ import { backAnchoredModuleZ, hoodCompartmentHeight, newCabinetCompartment, stac
  */
 export const CABINET_BASE_WIDTH = 0.5;
 export const CABINET_WALL_DEPTH = 0.32;
-export const CABINET_BASE_DEPTH = 0.5;
-export const CABINET_WALL_CARCASS_HEIGHT = 0.72;
-export const CABINET_TALL_DEPTH = 0.58;
-export const CABINET_TALL_PLINTH_HEIGHT = 0.1;
+export const CABINET_BASE_DEPTH = CABINET_METRIC_DEFAULTS.depth;
+export const CABINET_WALL_CARCASS_HEIGHT = CABINET_METRIC_DEFAULTS.carcassHeight;
+export const CABINET_TALL_DEPTH = CABINET_METRIC_DEFAULTS.depth;
+export const CABINET_TALL_PLINTH_HEIGHT = CABINET_METRIC_DEFAULTS.plinthHeight;
 export const CABINET_TALL_CARCASS_HEIGHT = 2.07;
 export const CABINET_EDGE_EPSILON = 1e-4;
 const MIN_CORNER_CONNECTED_WIDTH = 0.3;
@@ -201,6 +201,10 @@ export function totalCabinetHeight(node) {
         node.carcassHeight +
         (node.withCountertop ? node.countertopThickness : 0));
 }
+export function cabinetModuleTotalHeight(node) {
+    return (totalCabinetHeight(node) +
+        (node.topFinish === 'top-cabinet' || node.topFinish === 'trim' ? node.topFinishHeight : 0));
+}
 /** Y where a wall cabinet's bottom lands so its top aligns with a tall unit's top. */
 export function wallBottomHeightForTallAlignment() {
     return (totalCabinetHeight({
@@ -211,6 +215,49 @@ export function wallBottomHeightForTallAlignment() {
         countertopThickness: 0,
     }) - CABINET_WALL_CARCASS_HEIGHT);
 }
+/** Resolve the remaining vertical space above a wall/tall module. */
+function cabinetCeilingContext(node, nodes) {
+    let worldY = node.position[1];
+    let current = node;
+    const visited = new Set();
+    let level;
+    while (current.parentId) {
+        const currentId = current.id;
+        if (visited.has(currentId))
+            break;
+        visited.add(currentId);
+        const parent = nodes[current.parentId];
+        if (!parent)
+            break;
+        if (parent.type === 'level') {
+            level = parent;
+            break;
+        }
+        if (parent.type !== 'cabinet' && parent.type !== 'cabinet-module')
+            break;
+        worldY += parent.position[1];
+        current = parent;
+    }
+    const ceilingHeight = level?.type === 'level' && typeof level.height === 'number'
+        ? level.height
+        : DEFAULT_CEILING_HEIGHT;
+    return { ceilingHeight, worldY };
+}
+/** Resolve the remaining vertical space above a wall/tall module. */
+export function cabinetCeilingGap(node, nodes) {
+    const { ceilingHeight, worldY } = cabinetCeilingContext(node, nodes);
+    const currentTop = worldY + node.carcassHeight + (node.withCountertop ? node.countertopThickness : 0);
+    return Math.min(1.2, Math.max(0, ceilingHeight - currentTop));
+}
+/** Resolve how far a module's carcass and top finish extend above the ceiling. */
+export function cabinetModuleCeilingOverflow(node, nodes) {
+    const { ceilingHeight, worldY } = cabinetCeilingContext(node, nodes);
+    const currentTop = worldY +
+        node.carcassHeight +
+        (node.withCountertop ? node.countertopThickness : 0) +
+        (node.topFinish === 'top-cabinet' || node.topFinish === 'trim' ? node.topFinishHeight : 0);
+    return Math.max(0, currentTop - ceilingHeight);
+}
 /** Local Z offset that makes a shallower wall cabinet's back flush with its deeper base. */
 export function backAlignZ(baseDepth, wallDepth) {
     return -(baseDepth - wallDepth) / 2;
@@ -223,6 +270,44 @@ export function wallChildOf(module, nodes) {
     }
     return null;
 }
+export function nestedCornerRunPositionOverrides(module, nextPosition, nodes) {
+    const dx = nextPosition[0] - module.position[0];
+    const dy = nextPosition[1] - module.position[1];
+    const dz = nextPosition[2] - module.position[2];
+    if (Math.abs(dx) <= CABINET_EDGE_EPSILON &&
+        Math.abs(dy) <= CABINET_EDGE_EPSILON &&
+        Math.abs(dz) <= CABINET_EDGE_EPSILON) {
+        return [];
+    }
+    const cos = Math.cos(module.rotation);
+    const sin = Math.sin(module.rotation);
+    return Object.values(nodes).flatMap((node) => {
+        if (node?.type !== 'cabinet' || node.parentId !== module.id)
+            return [];
+        const link = cornerDerivedRunLink(node.metadata);
+        if (link?.role !== 'bridge' && link?.role !== 'wall-leg')
+            return [];
+        return [
+            [
+                node.id,
+                {
+                    position: [
+                        node.position[0] - (dx * cos - dz * sin),
+                        node.position[1] - dy,
+                        node.position[2] - (dx * sin + dz * cos),
+                    ],
+                },
+            ],
+        ];
+    });
+}
+export function applyCabinetModuleFrontPatch({ module, patch, sceneApi, }) {
+    sceneApi.update(module.id, patch);
+    const wallChild = wallChildOf(module, sceneApi.nodes());
+    if (wallChild) {
+        sceneApi.update(wallChild.id, patch);
+    }
+}
 export function resolveCabinetType(module, run) {
     if (module.cabinetType)
         return module.cabinetType;
@@ -233,6 +318,212 @@ export function cabinetModulesForRun(run, nodes) {
         .map((id) => nodes[id])
         .filter((child) => child?.type === 'cabinet-module');
 }
+const EQUALIZABLE_CABINET_COMPARTMENTS = new Set(['shelf', 'drawer', 'door']);
+export function cabinetModuleCanEqualizeWidth(module, run) {
+    return (module.moduleKind !== 'corner-filler' &&
+        resolveCabinetType(module, run) === 'base' &&
+        stackForCabinet(module).every((compartment) => EQUALIZABLE_CABINET_COMPARTMENTS.has(compartment.type)));
+}
+export function cabinetRunWidthEqualizationPlan(run, nodes) {
+    const modules = cabinetModulesForRun(run, nodes);
+    const equalizedIds = new Set(modules
+        .filter((module) => cabinetModuleCanEqualizeWidth(module, run))
+        .map((module) => module.id));
+    const minimumWidthById = new Map(modules
+        .filter((module) => equalizedIds.has(module.id))
+        .map((module) => [
+        module.id,
+        cornerSourceLink(module.metadata) ? MIN_TRIMMED_CORNER_CONNECTED_WIDTH : MIN_CABINET_WIDTH,
+    ]));
+    const maximumWidthById = new Map(modules
+        .filter((module) => equalizedIds.has(module.id))
+        .map((module) => [module.id, MAX_CABINET_WIDTH]));
+    return planRunModuleWidthEqualization({
+        modules,
+        equalizedIds,
+        minimumWidthById,
+        maximumWidthById,
+    });
+}
+export function equalizeCabinetRunWidths({ run, sceneApi, }) {
+    const liveRun = sceneApi.get(run.id);
+    if (!liveRun)
+        return false;
+    const previousModules = cabinetModulesForRun(liveRun, sceneApi.nodes());
+    const plan = cabinetRunWidthEqualizationPlan(liveRun, sceneApi.nodes());
+    if (!plan.ok || !plan.changed)
+        return false;
+    sceneApi.pauseHistory();
+    try {
+        for (const planned of plan.modules) {
+            const module = sceneApi.get(planned.id);
+            if (!module || module.parentId !== liveRun.id)
+                throw new Error('Cabinet run changed');
+            const nextPosition = [
+                planned.position[0],
+                module.position[1],
+                planned.position[2],
+            ];
+            const nestedCornerOverrides = nestedCornerRunPositionOverrides(module, nextPosition, sceneApi.nodes());
+            sceneApi.update(module.id, {
+                position: nextPosition,
+                width: planned.width,
+            });
+            for (const [id, override] of nestedCornerOverrides)
+                sceneApi.update(id, override);
+            const wallChild = wallChildOf(module, sceneApi.nodes());
+            if (wallChild) {
+                sceneApi.update(wallChild.id, {
+                    position: [0, wallChild.position[1], backAlignZ(module.depth, wallChild.depth)],
+                    width: planned.width,
+                });
+            }
+        }
+        syncCornerRunsFromRunSources({
+            baseLayout: 'width-only',
+            previousModules,
+            run: sceneApi.get(liveRun.id) ?? liveRun,
+            sceneApi,
+        });
+        bumpCabinetRunLayoutRevision(sceneApi, liveRun);
+        sceneApi.resumeHistory();
+        return true;
+    }
+    catch {
+        sceneApi.restoreAll();
+        sceneApi.resumeHistory();
+        return false;
+    }
+}
+export function cabinetRunArrayPlan(run, nodes, options) {
+    if (!options.sourceModuleId)
+        return { ok: false, reason: 'no-source' };
+    if (!Number.isInteger(options.copyCount) ||
+        options.copyCount < 1 ||
+        options.copyCount > 20 ||
+        !Number.isFinite(options.spacing) ||
+        options.spacing < 0 ||
+        options.spacing > 2) {
+        return { ok: false, reason: 'invalid-options' };
+    }
+    const modules = cabinetModulesForRun(run, nodes);
+    const source = modules.find((module) => module.id === options.sourceModuleId);
+    if (!source || source.moduleKind === 'corner-filler') {
+        return { ok: false, reason: 'no-source' };
+    }
+    const direction = options.direction === 'left' ? -1 : 1;
+    const step = source.width + options.spacing;
+    const positions = Array.from({ length: options.copyCount }, (_, index) => [
+        source.position[0] + direction * step * (index + 1),
+        source.position[1],
+        source.position[2],
+    ]);
+    const epsilon = CABINET_EDGE_EPSILON;
+    for (const position of positions) {
+        const minX = position[0] - source.width / 2;
+        const maxX = position[0] + source.width / 2;
+        const overlaps = modules.some((module) => {
+            if (module.id === source.id)
+                return false;
+            return moduleMinX(module) < maxX - epsilon && moduleMaxX(module) > minX + epsilon;
+        });
+        if (overlaps)
+            return { ok: false, reason: 'no-space' };
+    }
+    const constraints = runWallConstraints(run, modules, nodes);
+    const currentMinX = Math.min(...modules.map(moduleMinX));
+    const currentMaxX = Math.max(...modules.map(moduleMaxX));
+    const plannedMinX = Math.min(currentMinX, ...positions.map((position) => position[0] - source.width / 2));
+    const plannedMaxX = Math.max(currentMaxX, ...positions.map((position) => position[0] + source.width / 2));
+    if ((constraints.left.constrained &&
+        currentMinX - plannedMinX > constraints.left.slack + epsilon) ||
+        (constraints.right.constrained && plannedMaxX - currentMaxX > constraints.right.slack + epsilon)) {
+        return { ok: false, reason: 'no-space' };
+    }
+    return { ok: true, sourceModuleId: source.id, positions };
+}
+function cleanCabinetArrayMetadata(metadata) {
+    const { cabinetCornerDerivedRun: _derived, cabinetCornerSourceLink: _source, isNew: _isNew, nodeSelectionProxyId: _proxy, ...rest } = cabinetMetadataRecord(metadata);
+    return rest;
+}
+function cabinetArrayCloneNodes(source, position, sceneApi) {
+    const subtree = sceneApi.getSubtree(source.id);
+    if (!subtree)
+        return null;
+    const duplicable = nodeRegistry.get(source.type)?.capabilities?.duplicable;
+    const prepared = duplicable && typeof duplicable === 'object' && duplicable.prepareSubtreeClone
+        ? duplicable.prepareSubtreeClone({
+            root: subtree.root,
+            descendants: subtree.descendants,
+            rootId: source.id,
+            rootPatch: { position },
+            nodes: sceneApi.nodes(),
+        })
+        : null;
+    const root = {
+        ...(prepared?.root ?? subtree.root),
+        metadata: cleanCabinetArrayMetadata((prepared?.root ?? subtree.root).metadata),
+    };
+    root.position = position;
+    const descendants = (prepared?.descendants ?? subtree.descendants).map((node) => ({
+        ...node,
+        metadata: cleanCabinetArrayMetadata(node.metadata),
+    }));
+    return cloneNodesInto([root, ...descendants], {
+        parentId: source.parentId,
+        rootId: source.id,
+        position,
+    }).nodes;
+}
+export function duplicateCabinetModuleAlongRun({ run, sceneApi, sourceModuleId, copyCount, spacing, direction, }) {
+    const liveRun = sceneApi.get(run.id);
+    if (!liveRun)
+        return null;
+    const plan = cabinetRunArrayPlan(liveRun, sceneApi.nodes(), {
+        copyCount,
+        direction,
+        sourceModuleId,
+        spacing,
+    });
+    if (!plan.ok)
+        return null;
+    const source = sceneApi.get(plan.sourceModuleId);
+    if (!source)
+        return null;
+    const clonedNodes = [];
+    const clonedRootIds = [];
+    for (const position of plan.positions) {
+        const clone = cabinetArrayCloneNodes(source, position, sceneApi);
+        if (!clone || clone.length === 0)
+            return null;
+        clonedRootIds.push(clone[0].id);
+        clonedNodes.push(...clone);
+    }
+    sceneApi.pauseHistory();
+    try {
+        const createMany = sceneApi.createMany;
+        const clonedRootIdSet = new Set(clonedRootIds);
+        if (createMany) {
+            createMany(clonedNodes.map((node) => clonedRootIdSet.has(node.id)
+                ? { node, parentId: liveRun.id }
+                : { node }));
+        }
+        else {
+            for (const node of clonedNodes) {
+                const isRoot = clonedRootIdSet.has(node.id);
+                sceneApi.upsert(node, isRoot ? liveRun.id : undefined);
+            }
+        }
+        bumpCabinetRunLayoutRevision(sceneApi, liveRun);
+        sceneApi.resumeHistory();
+        return clonedRootIds;
+    }
+    catch {
+        sceneApi.restoreAll();
+        sceneApi.resumeHistory();
+        return null;
+    }
+}
 export function backAlignedRunDepthOverrides(run, nodes, depth) {
     const modules = cabinetModulesForRun(run, nodes);
     if (modules.length === 0)
@@ -475,9 +766,40 @@ export function cornerSourceWidthOverridesForDerivedDepth(run, nodes, depth) {
 export function cornerSourceModulesForRun(run, nodes) {
     return cabinetModulesForRun(run, nodes).filter((module) => cornerSourceLink(module.metadata) != null);
 }
+export function cornerPinnedEndsForRun(modules) {
+    if (modules.length === 0)
+        return {};
+    const sorted = sortRunModules(modules);
+    const leftEdge = moduleMinX(sorted[0]);
+    const rightEdge = moduleMaxX(sorted.at(-1));
+    const pinned = {};
+    for (const module of sorted) {
+        const side = cornerSourceLink(module.metadata)?.side;
+        if (side === 'left' && Math.abs(moduleMinX(module) - leftEdge) <= CABINET_EDGE_EPSILON) {
+            pinned.left = true;
+        }
+        if (side === 'right' && Math.abs(moduleMaxX(module) - rightEdge) <= CABINET_EDGE_EPSILON) {
+            pinned.right = true;
+        }
+    }
+    return pinned;
+}
 function doorStack(shelfCount) {
     return [{ ...newCabinetCompartment('door'), shelfCount }];
 }
+function cloneCabinetStack(module) {
+    return stackForCabinet(module).map((compartment) => ({
+        ...compartment,
+        id: newCabinetCompartment(compartment.type).id,
+    }));
+}
+const STORAGE_COMPARTMENT_TYPES = new Set(['shelf', 'drawer', 'door']);
+function sideAdditionStack(module) {
+    const stack = stackForCabinet(module);
+    return stack.every((compartment) => STORAGE_COMPARTMENT_TYPES.has(compartment.type))
+        ? cloneCabinetStack(module)
+        : defaultCabinetStack(module);
+}
 function cloneWallCabinetStack(sourceWallTop, shelfCount) {
     if (!sourceWallTop)
         return doorStack(shelfCount);
@@ -711,9 +1033,18 @@ function resolveWallLimitedWidth({ backLeft, desiredWidth, depth, leadingOffset,
         position: [backLeft[0], 0, backLeft[1]],
         rotation,
     };
+    const runAxis = [Math.cos(rotation), -Math.sin(rotation)];
     const miterData = calculateLevelMiters(walls);
     let blockingDistance = Number.POSITIVE_INFINITY;
     for (const wall of walls) {
+        const wallDx = wall.end[0] - wall.start[0];
+        const wallDz = wall.end[1] - wall.start[1];
+        const wallLength = Math.hypot(wallDx, wallDz);
+        if (wallLength <= WALL_CLEARANCE_EPSILON)
+            continue;
+        const axisDot = (wallDx * runAxis[0] + wallDz * runAxis[1]) / wallLength;
+        if (Math.abs(axisDot) > 0.2)
+            continue;
         const footprint = getWallPlanFootprint(wall, miterData);
         if (footprint.length < 3)
             continue;
@@ -842,9 +1173,15 @@ function computeCornerRunLayout({ module, run, nodes, side, turnSide = side, sou
     const corner = runLocalToPlan(runWorld, [cornerX, 0, backZ]);
     const sourceAxis = [Math.cos(runWorld.rotation), -Math.sin(runWorld.rotation)];
     const sign = side === 'right' ? 1 : -1;
+    const sourceWallConstraint = runWallConstraints(run, modules, nodes, {
+        widthGrowth: baseLegDepth,
+    })[side];
+    const sideWallInset = turnSide === side && sourceWallConstraint.constrained
+        ? Math.max(0, baseLegDepth - sourceWallConstraint.slack)
+        : 0;
     const shiftedCorner = [
-        corner[0] + sign * baseLegDepth * sourceAxis[0],
-        corner[2] + sign * baseLegDepth * sourceAxis[1],
+        corner[0] + sign * (baseLegDepth - sideWallInset) * sourceAxis[0],
+        corner[2] + sign * (baseLegDepth - sideWallInset) * sourceAxis[1],
     ];
     const legRotation = turnSide === 'right' ? runWorld.rotation - Math.PI / 2 : runWorld.rotation + Math.PI / 2;
     const legAxis = [Math.cos(legRotation), -Math.sin(legRotation)];
@@ -1085,6 +1422,11 @@ function upsertCabinetRunWithModules({ depth, modulePatches, name, parentId, pos
             countertopOverhang: runTier === 'base' ? sourceRun.countertopOverhang : 0,
             showPlinth: false,
             withCountertop: false,
+            frontGap: sourceRun.frontGap,
+            frontStyle: sourceRun.frontStyle,
+            frontOverlay: sourceRun.frontOverlay,
+            handleStyle: sourceRun.handleStyle,
+            handlePosition: sourceRun.handlePosition,
             moduleKind: patch.moduleKind ?? 'standard',
             ...(patch.openSide ? { openSide: patch.openSide } : {}),
             ...(patch.cornerShelf ? { cornerShelf: true } : {}),
@@ -1228,12 +1570,42 @@ function syncDerivedCornerRun({ baseLayout, role, run, sourceModule, sourceRun,
             ? Math.min(...modules.map((entry) => entry.position[0] - entry.width / 2))
             : Math.max(...modules.map((entry) => entry.position[0] + entry.width / 2)) - nextTotalWidth;
         let cursor = fixedEdge;
+        const nextPositions = currentWidths.map((width) => {
+            const positionX = cursor + width / 2;
+            cursor += width;
+            return positionX;
+        });
+        const fillerName = role === 'base-leg' ? 'Corner Filler' : 'Corner Wall Filler';
+        const anchorModuleIndex = modules.findIndex((entry) => entry.name === fillerName);
+        const anchorModule = modules[anchorModuleIndex];
+        const canonicalAnchorIndex = anchorModule ? fullNames.indexOf(anchorModule.name) : -1;
+        if (anchorModule && canonicalAnchorIndex >= 0) {
+            const rotation = layout.legRotation;
+            const layoutRunPosition = role === 'base-leg' ? layout.baseRunPosition : layout.wallRunPosition;
+            const anchorWorldPosition = runLocalToPlan({ position: layoutRunPosition, rotation }, [
+                fullCenters[canonicalAnchorIndex] ?? 0,
+                0,
+                0,
+            ]);
+            const runWorldPosition = runLocalToPlan({ position: anchorWorldPosition, rotation }, [
+                -(nextPositions[anchorModuleIndex] ?? 0),
+                0,
+                -anchorModule.position[2],
+            ]);
+            const frameParent = cabinetFrameParent(run, sceneApi.nodes()) ?? sourceRun;
+            const runPosition = worldToCabinetLocalPosition(frameParent, sceneApi.nodes(), runWorldPosition);
+            const localRotation = worldToCabinetLocalRotation(frameParent, sceneApi.nodes(), rotation);
+            const positionChanged = runPosition.some((value, index) => Math.abs(value - run.position[index]) > CABINET_EDGE_EPSILON);
+            if (positionChanged ||
+                Math.abs(angleDelta(localRotation, run.rotation)) > CABINET_EDGE_EPSILON) {
+                sceneApi.update(run.id, { position: runPosition, rotation: localRotation });
+            }
+        }
         modules.forEach((entry, index) => {
             const spec = currentSpecs[index];
             if (!spec)
                 return;
-            const positionX = cursor + spec.width / 2;
-            cursor += spec.width;
+            const positionX = nextPositions[index] ?? entry.position[0];
             sceneApi.update(entry.id, {
                 width: spec.width,
                 position: [positionX, entry.position[1], entry.position[2]],
@@ -1333,8 +1705,6 @@ function syncDerivedCornerRun({ baseLayout, role, run, sourceModule, sourceRun,
             0,
             0,
         ]);
-    // Place relative to the derived run's ACTUAL parent frame — source run for
-    // new scenes, source module for legacy scenes that nested legs under it.
     const frameParent = cabinetFrameParent(run, sceneApi.nodes()) ?? sourceRun;
     const runPosition = worldToCabinetLocalPosition(frameParent, sceneApi.nodes(), runWorldPosition);
     const localRotation = worldToCabinetLocalRotation(frameParent, sceneApi.nodes(), rotation);
@@ -1379,7 +1749,9 @@ function syncDerivedCornerRun({ baseLayout, role, run, sourceModule, sourceRun,
             frontOverlay: sourceRun.frontOverlay,
             handleStyle: sourceRun.handleStyle,
             handlePosition: sourceRun.handlePosition,
-            stack: doorStack(layout.connectedShelfCount),
+            stack: role === 'base-leg' && entry.name === 'Base Cabinet'
+                ? cloneCabinetStack(sourceModule)
+                : doorStack(layout.connectedShelfCount),
             metadata: entry.metadata,
         });
     });
@@ -1399,10 +1771,29 @@ function syncDerivedCornerRun({ baseLayout, role, run, sourceModule, sourceRun,
     }
     bumpCabinetRunLayoutRevision(sceneApi, sceneApi.get(run.id) ?? run);
 }
-export function syncCornerRunsFromSourceModule({ baseLayout = 'full', module, run, sceneApi, }) {
+export function syncCornerRunsFromSourceModule({ baseLayout = 'full', module, previousModule, run, sceneApi, }) {
     const link = cornerSourceLink(module.metadata);
     if (!link)
         return;
+    if (previousModule) {
+        const previousEdge = link.side === 'left' ? moduleMinX(previousModule) : moduleMaxX(previousModule);
+        const nextEdge = link.side === 'left' ? moduleMinX(module) : moduleMaxX(module);
+        const edgeShift = nextEdge - previousEdge;
+        if (Math.abs(edgeShift) > CABINET_EDGE_EPSILON) {
+            for (const runId of link.linkedRunIds) {
+                const linkedRun = sceneApi.get(runId);
+                if (linkedRun?.type !== 'cabinet' || linkedRun.parentId !== run.id)
+                    continue;
+                sceneApi.update(linkedRun.id, {
+                    position: [
+                        linkedRun.position[0] + edgeShift,
+                        linkedRun.position[1],
+                        linkedRun.position[2],
+                    ],
+                });
+            }
+        }
+    }
     for (const runId of link.linkedRunIds) {
         const linkedRun = sceneApi.get(runId);
         if (linkedRun?.type !== 'cabinet')
@@ -1422,11 +1813,35 @@ export function syncCornerRunsFromSourceModule({ baseLayout = 'full', module, ru
         });
     }
 }
-export function syncCornerRunsFromRunSources({ baseLayout = 'full', run, sceneApi, }) {
+export function syncCornerRunsFromRunSources({ baseLayout = 'full', previousModules = [], run, sceneApi, }) {
     const effectiveBaseLayout = baseLayout === 'width-only' && !cornerDerivedRunLink(run.metadata)
         ? 'preserve-connected-widths'
         : baseLayout;
+    const previousModulesById = new Map(previousModules.map((module) => [module.id, module]));
     for (const sourceModule of cornerSourceModulesForRun(run, sceneApi.nodes())) {
+        const previousModule = previousModulesById.get(sourceModule.id);
+        const sourceLink = previousModule ? cornerSourceLink(sourceModule.metadata) : null;
+        if (previousModule && sourceLink) {
+            const previousEdge = sourceLink.side === 'left' ? moduleMinX(previousModule) : moduleMaxX(previousModule);
+            const nextEdge = sourceLink.side === 'left' ? moduleMinX(sourceModule) : moduleMaxX(sourceModule);
+            const edgeShift = nextEdge - previousEdge;
+            if (Math.abs(edgeShift) > CABINET_EDGE_EPSILON) {
+                // Move the direct leg first so it stays attached even when a wall makes
+                // the canonical corner re-layout reject the otherwise valid live shape.
+                for (const linkedRunId of sourceLink.linkedRunIds) {
+                    const linkedRun = sceneApi.get(linkedRunId);
+                    if (linkedRun?.type !== 'cabinet' || linkedRun.parentId !== run.id)
+                        continue;
+                    sceneApi.update(linkedRun.id, {
+                        position: [
+                            linkedRun.position[0] + edgeShift,
+                            linkedRun.position[1],
+                            linkedRun.position[2],
+                        ],
+                    });
+                }
+            }
+        }
         syncCornerRunsFromSourceModule({
             baseLayout: effectiveBaseLayout,
             module: sourceModule,
@@ -1435,7 +1850,7 @@ export function syncCornerRunsFromRunSources({ baseLayout = 'full', run, sceneAp
         });
     }
 }
-export function previewCornerRunsFromRunSources({ baseLayout = 'full', initialOverrides = [], run, sceneApi, }) {
+export function previewCornerRunsFromRunSources({ baseLayout = 'full', initialOverrides = [], previousModules = [], run, sceneApi, }) {
     const overrides = new Map();
     for (const [id, patch] of initialOverrides) {
         overrides.set(id, { ...(overrides.get(id) ?? {}), ...patch });
@@ -1458,29 +1873,41 @@ export function previewCornerRunsFromRunSources({ baseLayout = 'full', initialOv
         },
         markDirty: () => { },
     };
-    syncCornerRunsFromRunSources({ baseLayout, run, sceneApi: previewSceneApi });
+    syncCornerRunsFromRunSources({
+        baseLayout,
+        previousModules,
+        run,
+        sceneApi: previewSceneApi,
+    });
     return [...overrides];
 }
 /**
  * Insert a new base module flush against the anchor's side (or the run's
- * outer edge with no anchor). Gap-checked — returns null when a flush
- * neighbor leaves no room for a standard-width unit.
+ * outer edge with no anchor). A full run is reflowed when the anchor has a
+ * flush neighbor, subject to wall and filler capacity.
  */
 export function planCabinetModuleSideAddition({ anchorModule, nodes, run, side, }) {
     const modules = cabinetModulesForRun(run, nodes);
-    const x = sideInsertX({
+    const directX = sideInsertX({
         anchorModule,
         modules,
         side,
         width: CABINET_BASE_WIDTH,
         epsilon: CABINET_EDGE_EPSILON,
     });
+    const x = directX ??
+        (anchorModule
+            ? side === 'left'
+                ? moduleMinX(anchorModule) - CABINET_BASE_WIDTH / 2
+                : moduleMaxX(anchorModule) + CABINET_BASE_WIDTH / 2
+            : null);
     if (x == null)
         return null;
     const sortedModules = sortRunModules(modules);
     const depthSource = anchorModule ?? (side === 'left' ? sortedModules[0] : sortedModules.at(-1)) ?? null;
     const depth = depthSource?.depth ?? run.depth;
     const z = depthSource ? backAnchoredModuleZ(depthSource.position[2], depthSource.depth, depth) : 0;
+    const structureSource = anchorModule ?? depthSource;
     const width = resolveSideAddedModuleWidth({
         centerX: x,
         centerZ: z,
@@ -1493,7 +1920,7 @@ export function planCabinetModuleSideAddition({ anchorModule, nodes, run, side,
     });
     if (width < MIN_CORNER_CONNECTED_WIDTH - WALL_CLEARANCE_EPSILON)
         return null;
-    return CabinetModuleNodeSchema.parse({
+    const module = CabinetModuleNodeSchema.parse({
         name: `Base Cabinet ${modules.length + 1}`,
         parentId: run.id,
         position: [
@@ -1510,20 +1937,82 @@ export function planCabinetModuleSideAddition({ anchorModule, nodes, run, side,
         countertopOverhang: run.countertopOverhang,
         showPlinth: false,
         withCountertop: false,
+        frontGap: structureSource?.frontGap ?? run.frontGap,
+        frontStyle: structureSource?.frontStyle ?? run.frontStyle,
+        frontOverlay: structureSource?.frontOverlay ?? run.frontOverlay,
+        handleStyle: structureSource?.handleStyle ?? run.handleStyle,
+        handlePosition: structureSource?.handlePosition ?? run.handlePosition,
+        ...(structureSource ? { stack: sideAdditionStack(structureSource) } : {}),
     });
+    if (directX == null && anchorModule) {
+        const insertionPlan = planRunModuleInsertion({
+            modules,
+            insertion: {
+                id: module.id,
+                position: module.position,
+                width: module.width,
+            },
+            wallConstraints: runWallConstraints(run, modules, nodes),
+            fillerIds: new Set(modules
+                .filter((candidate) => candidate.moduleKind === 'corner-filler')
+                .map((candidate) => candidate.id)),
+            preserveEnds: cornerPinnedEndsForRun(modules),
+        });
+        if (!insertionPlan.ok)
+            return null;
+    }
+    return module;
 }
 export function addCabinetModuleSide({ anchorModule, run, sceneApi, side, }) {
+    const nodes = sceneApi.nodes();
+    const modules = cabinetModulesForRun(run, nodes);
+    const directX = sideInsertX({
+        anchorModule,
+        modules,
+        side,
+        width: CABINET_BASE_WIDTH,
+        epsilon: CABINET_EDGE_EPSILON,
+    });
     const module = planCabinetModuleSideAddition({
         anchorModule,
-        nodes: sceneApi.nodes(),
+        nodes,
         run,
         side,
     });
     if (!module)
         return null;
-    sceneApi.upsert(module, run.id);
+    let committedModule = module;
+    if (directX == null && anchorModule) {
+        const result = planRunModuleInsertion({
+            modules,
+            insertion: {
+                id: module.id,
+                position: module.position,
+                width: module.width,
+            },
+            wallConstraints: runWallConstraints(run, modules, nodes),
+            fillerIds: new Set(modules
+                .filter((candidate) => candidate.moduleKind === 'corner-filler')
+                .map((candidate) => candidate.id)),
+            preserveEnds: cornerPinnedEndsForRun(modules),
+        });
+        if (!result.ok)
+            return null;
+        for (const planned of result.modules) {
+            sceneApi.update(planned.id, {
+                position: planned.position,
+                width: planned.width,
+            });
+        }
+        committedModule = CabinetModuleNodeSchema.parse({
+            ...module,
+            position: result.inserted.position,
+            width: result.inserted.width,
+        });
+    }
+    sceneApi.upsert(committedModule, run.id);
     bumpCabinetRunLayoutRevision(sceneApi, run);
-    return module.id;
+    return committedModule.id;
 }
 /**
  * Spawn an L corner off one open end of a base run: a perpendicular base leg
@@ -1589,8 +2078,6 @@ export function addCornerRun({ module, run, sceneApi, side, }) {
     const existingWallTop = sourceWallChildId
         ? (sceneApi.get(sourceWallChildId) ?? null)
         : wallChildOf(sourceModule, sceneApi.nodes());
-    // Legs are siblings of the source module under the SOURCE RUN — the run is
-    // the modular cabinet group; the clicked module must not become a container.
     const baseLocalPosition = worldToCabinetLocalPosition(sourceRun, sceneApi.nodes(), baseRunPosition);
     const baseLocalRotation = worldToCabinetLocalRotation(sourceRun, sceneApi.nodes(), legRotation);
     const baseModules = endSide === 'right'
@@ -1607,7 +2094,7 @@ export function addCornerRun({ module, run, sceneApi, side, }) {
                 name: 'Base Cabinet',
                 width: connectedWidth,
                 openSide: 'left',
-                stack: doorStack(connectedShelfCount),
+                stack: cloneCabinetStack(sourceModule),
             },
         ]
         : [
@@ -1615,7 +2102,7 @@ export function addCornerRun({ module, run, sceneApi, side, }) {
                 name: 'Base Cabinet',
                 width: connectedWidth,
                 openSide: 'right',
-                stack: doorStack(connectedShelfCount),
+                stack: cloneCabinetStack(sourceModule),
             },
             {
                 name: 'Corner Filler',
@@ -1639,7 +2126,7 @@ export function addCornerRun({ module, run, sceneApi, side, }) {
     });
     const selectionRootId = cornerSelectionRootId(sourceRun, baseLeg.runId);
     const linkedRunIds = [baseLeg.runId];
-    const baseLegLiveMetadata = sceneApi.get(baseLeg.runId)?.metadata ?? null;
+    const baseLegLiveMetadata = sceneApi.get(baseLeg.runId)?.metadata ?? {};
     const baseLegMetadata = cabinetMetadataRecord(baseLegLiveMetadata);
     sceneApi.update(baseLeg.runId, {
         metadata: {
@@ -1696,7 +2183,7 @@ export function addCornerRun({ module, run, sceneApi, side, }) {
                 sourceRun,
             });
             linkedRunIds.push(bridgeRun.runId);
-            const bridgeRunLiveMetadata = sceneApi.get(bridgeRun.runId)?.metadata ?? null;
+            const bridgeRunLiveMetadata = sceneApi.get(bridgeRun.runId)?.metadata ?? {};
             const bridgeRunMetadata = cabinetMetadataRecord(bridgeRunLiveMetadata);
             sceneApi.update(bridgeRun.runId, {
                 metadata: {
@@ -1740,7 +2227,7 @@ export function addCornerRun({ module, run, sceneApi, side, }) {
             sourceRun,
         });
         linkedRunIds.push(wallFillerRun.runId);
-        const wallFillerRunLiveMetadata = sceneApi.get(wallFillerRun.runId)?.metadata ?? null;
+        const wallFillerRunLiveMetadata = sceneApi.get(wallFillerRun.runId)?.metadata ?? {};
         const wallFillerRunMetadata = cabinetMetadataRecord(wallFillerRunLiveMetadata);
         sceneApi.update(wallFillerRun.runId, {
             metadata: {
@@ -1774,7 +2261,7 @@ export function addCornerRun({ module, run, sceneApi, side, }) {
             setCabinetSelectionProxy(sceneApi, wallChildId, selectionRootId);
         }
     }
-    const liveSourceMetadata = sceneApi.get(sourceModule.id)?.metadata ?? null;
+    const liveSourceMetadata = sceneApi.get(sourceModule.id)?.metadata ?? {};
     const sourceMetadata = cabinetMetadataRecord(liveSourceMetadata);
     const existingSourceLink = cornerSourceLink(liveSourceMetadata);
     sceneApi.update(sourceModule.id, {