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

package/dist/cabinet/run-layout.js

@@ -1,3 +1,4 @@
+import { resolveLevelId } from '@pascal-app/core';
 /**
  * Straight-line run layout math — the single home for the "modules sit on the
  * run's local X axis" assumption. Ordering, edges, adjacency, spans, and
@@ -7,6 +8,8 @@
 export const RUN_ADJACENCY_EPSILON = 1e-4;
 const ADJACENT_RUN_EPSILON = 1e-4;
 const ADJACENT_RUN_Z_TOLERANCE = 0.03;
+const REFLOW_CAPACITY_EPSILON = 1e-9;
+const OPEN_RUN_END = { constrained: false, slack: 0 };
 export function sortRunModules(modules) {
     return [...modules].sort((a, b) => a.position[0] - b.position[0]);
 }
@@ -16,6 +19,98 @@ export function moduleMinX(module) {
 export function moduleMaxX(module) {
     return module.position[0] + module.width / 2;
 }
+function levelIdForRun(run, nodes) {
+    let parentId = run.parentId;
+    const visited = new Set();
+    while (parentId && !visited.has(parentId)) {
+        visited.add(parentId);
+        const parent = nodes[parentId];
+        if (!parent)
+            return null;
+        if (parent.type === 'level')
+            return parent.id;
+        parentId = parent.parentId;
+    }
+    return null;
+}
+function runInLevelFrame(run, nodes) {
+    let position = [...run.position];
+    let rotation = run.rotation;
+    let parentId = run.parentId;
+    const visited = new Set();
+    while (parentId && !visited.has(parentId)) {
+        visited.add(parentId);
+        const parent = nodes[parentId];
+        if (parent?.type !== 'cabinet' && parent?.type !== 'cabinet-module')
+            break;
+        position = runLocalToPlan(parent, position);
+        rotation += parent.rotation;
+        parentId = parent.parentId;
+    }
+    return { depth: run.depth, position, rotation };
+}
+function closestPointOnSegment(point, start, end) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const lengthSquared = dx * dx + dz * dz;
+    if (lengthSquared <= 1e-8)
+        return start;
+    const t = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / lengthSquared));
+    return [start[0] + t * dx, start[1] + t * dz];
+}
+function wallConstraintAtRunEnd({ endX, run, side, walls, widthGrowth, }) {
+    const worldPoint = runLocalToPlan(run, [endX, 0, 0]);
+    const point = [worldPoint[0], worldPoint[2]];
+    const runAxis = [Math.cos(run.rotation), -Math.sin(run.rotation)];
+    const maxDistance = Math.max(run.depth / 2 + 0.08, widthGrowth);
+    const direction = side === 'left' ? -1 : 1;
+    let closestSlack = Number.POSITIVE_INFINITY;
+    for (const wall of walls) {
+        const dx = wall.end[0] - wall.start[0];
+        const dz = wall.end[1] - wall.start[1];
+        const length = Math.hypot(dx, dz);
+        if (length <= 1e-6)
+            continue;
+        const wallAxis = [dx / length, dz / length];
+        const axisDot = runAxis[0] * wallAxis[0] + runAxis[1] * wallAxis[1];
+        if (Math.abs(axisDot) > 0.2)
+            continue;
+        const closest = closestPointOnSegment(point, wall.start, wall.end);
+        const offsetX = (closest[0] - point[0]) * runAxis[0] + (closest[1] - point[1]) * runAxis[1];
+        const halfThickness = ((wall.thickness ?? 0.2) / 2) * Math.sqrt(1 - axisDot * axisDot);
+        const distance = Math.hypot(point[0] - closest[0], point[1] - closest[1]);
+        if (distance > maxDistance + (wall.thickness ?? 0.2) / 2 + RUN_ADJACENCY_EPSILON)
+            continue;
+        if (direction * offsetX < -halfThickness - RUN_ADJACENCY_EPSILON)
+            continue;
+        const slack = Math.max(0, direction * offsetX - halfThickness);
+        closestSlack = Math.min(closestSlack, slack);
+    }
+    return Number.isFinite(closestSlack) ? { constrained: true, slack: closestSlack } : OPEN_RUN_END;
+}
+export function runWallConstraints(run, modules, nodes, options = {}) {
+    const levelId = levelIdForRun(run, nodes);
+    if (!levelId)
+        return { left: OPEN_RUN_END, right: OPEN_RUN_END };
+    const walls = Object.values(nodes).filter((node) => node?.type === 'wall' &&
+        resolveLevelId(node, nodes) === levelId);
+    if (walls.length === 0)
+        return { left: OPEN_RUN_END, right: OPEN_RUN_END };
+    const minX = modules.length > 0 ? runMinX(modules) : -run.width / 2;
+    const maxX = modules.length > 0 ? runMaxX(modules) : run.width / 2;
+    const levelRun = runInLevelFrame(run, nodes);
+    const widthGrowth = Math.max(0, options.widthGrowth ?? 0);
+    return {
+        left: wallConstraintAtRunEnd({ endX: minX, run: levelRun, side: 'left', walls, widthGrowth }),
+        right: wallConstraintAtRunEnd({
+            endX: maxX,
+            run: levelRun,
+            side: 'right',
+            walls,
+            widthGrowth,
+        }),
+    };
+}
 export function runMinX(modules) {
     return Math.min(...modules.map(moduleMinX));
 }
@@ -46,8 +141,11 @@ export function moduleSideOpen(modules, moduleId, side, epsilon = RUN_ADJACENCY_
  * starts a new span.
  */
 export function getRunSpans(modules, opts = {}) {
+    return getRunSpanGroups(modules, opts).map((group) => group.span);
+}
+export function getRunSpanGroups(modules, opts = {}) {
     const sorted = [...modules].sort((a, b) => a.position[0] - b.position[0]);
-    const spans = [];
+    const groups = [];
     const runTier = opts.runTier ?? 'base';
     for (const module of sorted) {
         const minX = module.position[0] - module.width / 2;
@@ -56,27 +154,32 @@ export function getRunSpans(modules, opts = {}) {
         const maxZ = module.position[2] + module.depth / 2;
         const topY = module.position[1] + module.carcassHeight;
         const hasCountertop = runTier === 'base' && (module.cabinetType ?? 'base') !== 'tall';
-        const current = spans.at(-1);
+        const group = groups.at(-1);
+        const current = group?.span;
         if (!current ||
             minX - current.maxX > RUN_ADJACENCY_EPSILON ||
             current.hasCountertop !== hasCountertop ||
             Math.abs(current.topY - topY) > RUN_ADJACENCY_EPSILON ||
             Math.abs(current.minZ - minZ) > RUN_ADJACENCY_EPSILON ||
             Math.abs(current.maxZ - maxZ) > RUN_ADJACENCY_EPSILON) {
-            spans.push({
-                minX,
-                maxX,
-                centerX: module.position[0],
-                centerZ: module.position[2],
-                width: module.width,
-                depth: module.depth,
-                minZ,
-                maxZ,
-                topY,
-                hasCountertop,
+            groups.push({
+                modules: [module],
+                span: {
+                    minX,
+                    maxX,
+                    centerX: module.position[0],
+                    centerZ: module.position[2],
+                    width: module.width,
+                    depth: module.depth,
+                    minZ,
+                    maxZ,
+                    topY,
+                    hasCountertop,
+                },
             });
             continue;
         }
+        group.modules.push(module);
         current.maxX = Math.max(current.maxX, maxX);
         current.minZ = Math.min(current.minZ, minZ);
         current.maxZ = Math.max(current.maxZ, maxZ);
@@ -86,7 +189,7 @@ export function getRunSpans(modules, opts = {}) {
         current.centerZ = (current.minZ + current.maxZ) / 2;
         current.topY = Math.max(current.topY, topY);
     }
-    return spans;
+    return groups;
 }
 function angleDelta(a, b) {
     return Math.atan2(Math.sin(a - b), Math.cos(a - b));
@@ -282,8 +385,11 @@ export function sideInsertX({ anchorModule, modules, side, width, epsilon = RUN_
     return selectedRight + width / 2;
 }
 /**
- * Re-pack the run left-to-right after one module's width changes, keeping
- * every module flush with its left neighbor. Returns per-module patches.
+ * Re-pack the run after one module's width changes. A single constrained end
+ * may consume its wall gap. When both ends are constrained, the run extent is
+ * fixed and eligible donors absorb the growth, nearest first. Manual edge
+ * resize may consume an open inter-module gap before shifting its neighbor.
+ * The change is rejected only when their combined capacity is insufficient.
  */
 export function reflowRunModules(modules, selectedId, selectedWidth, options = {}) {
     const sorted = sortRunModules(modules);
@@ -293,50 +399,337 @@ export function reflowRunModules(modules, selectedId, selectedWidth, options = {
     const widths = new Map(sorted.map((module) => [module.id, module.width]));
     widths.set(selectedId, selectedWidth);
     const selected = sorted[selectedIndex];
-    let remainingGrowth = selectedWidth - selected.width;
-    if (options.preserveExtent && remainingGrowth > RUN_ADJACENCY_EPSILON) {
-        const minimumWidth = options.minimumWidth ?? 0.3;
-        const left = sorted.slice(0, selectedIndex).reverse();
-        const right = sorted.slice(selectedIndex + 1);
-        const capacity = (candidates) => candidates.reduce((total, module) => total + Math.max(0, module.width - minimumWidth), 0);
-        const candidates = capacity(left) > capacity(right) ? [...left, ...right] : [...right, ...left];
-        for (const module of candidates) {
-            if (remainingGrowth <= RUN_ADJACENCY_EPSILON)
-                break;
-            const available = Math.max(0, module.width - minimumWidth);
-            const reduction = Math.min(available, remainingGrowth);
-            widths.set(module.id, module.width - reduction);
-            remainingGrowth -= reduction;
+    const gaps = sorted.map((module, index) => {
+        const next = sorted[index + 1];
+        if (!next)
+            return 0;
+        return Math.max(0, moduleMinX(next) - moduleMaxX(module));
+    });
+    const wallConstraints = options.wallConstraints;
+    const leftConstrained = wallConstraints?.left.constrained ?? false;
+    const rightConstrained = wallConstraints?.right.constrained ?? false;
+    const preserveExtent = leftConstrained && rightConstrained;
+    const widthGrowth = selectedWidth - selected.width;
+    let remainingGrowth = Math.max(0, widthGrowth);
+    const resizeSide = options.resizeSide;
+    const layoutGaps = [...gaps];
+    let consumedAdjacentGap = 0;
+    if (options.consumeAdjacentGap && widthGrowth > REFLOW_CAPACITY_EPSILON && resizeSide) {
+        const adjacentGapSide = options.adjacentGapSide ?? resizeSide;
+        const adjacentGapIndex = adjacentGapSide === 'right' ? selectedIndex : selectedIndex - 1;
+        if (adjacentGapIndex >= 0 && adjacentGapIndex < layoutGaps.length) {
+            const adjacentGap = layoutGaps[adjacentGapIndex] ?? 0;
+            consumedAdjacentGap = Math.min(widthGrowth, adjacentGap);
+            layoutGaps[adjacentGapIndex] = adjacentGap - consumedAdjacentGap;
+        }
+    }
+    remainingGrowth -= consumedAdjacentGap;
+    const consumedRightSlack = rightConstrained && (!preserveExtent || resizeSide === 'right')
+        ? Math.min(remainingGrowth, Math.max(0, wallConstraints?.right.slack ?? 0))
+        : 0;
+    remainingGrowth -= consumedRightSlack;
+    const consumedLeftSlack = leftConstrained && (!preserveExtent || resizeSide === 'left')
+        ? Math.min(remainingGrowth, Math.max(0, wallConstraints?.left.slack ?? 0))
+        : 0;
+    remainingGrowth -= consumedLeftSlack;
+    if (preserveExtent && remainingGrowth > REFLOW_CAPACITY_EPSILON) {
+        const defaultMinimumWidth = options.minimumWidth ?? 0.3;
+        const minimumWidth = (module) => options.minimumWidthById?.get(module.id) ?? defaultMinimumWidth;
+        const donors = sorted
+            .map((module, index) => ({ index, module }))
+            .filter(({ module }) => module.id !== selectedId &&
+            (!options.eligibleDonorIds || options.eligibleDonorIds.has(module.id)) &&
+            module.width - minimumWidth(module) > REFLOW_CAPACITY_EPSILON)
+            .sort((a, b) => {
+            const distance = Math.abs(a.index - selectedIndex) - Math.abs(b.index - selectedIndex);
+            if (distance !== 0)
+                return distance;
+            const capacity = Math.max(0, b.module.width - Math.max(defaultMinimumWidth, minimumWidth(b.module))) -
+                Math.max(0, a.module.width - Math.max(defaultMinimumWidth, minimumWidth(a.module)));
+            if (capacity !== 0)
+                return capacity;
+            return b.index - a.index;
+        });
+        const available = donors.reduce((total, { module }) => total + Math.max(0, module.width - minimumWidth(module)), 0);
+        if (available + REFLOW_CAPACITY_EPSILON < remainingGrowth)
+            return [];
+        for (const useTrimCapacity of [false, true]) {
+            for (const { module } of donors) {
+                if (remainingGrowth <= REFLOW_CAPACITY_EPSILON)
+                    break;
+                const currentWidth = widths.get(module.id) ?? module.width;
+                const floor = useTrimCapacity
+                    ? minimumWidth(module)
+                    : Math.min(currentWidth, Math.max(defaultMinimumWidth, minimumWidth(module)));
+                const donation = Math.min(Math.max(0, currentWidth - floor), remainingGrowth);
+                widths.set(module.id, Math.max(floor, currentWidth - donation));
+                remainingGrowth -= donation;
+            }
         }
     }
     let remainingFreedWidth = selected.width - selectedWidth;
-    if (options.preserveExtent &&
-        remainingFreedWidth > RUN_ADJACENCY_EPSILON &&
-        options.restorableWidthById) {
+    if (remainingFreedWidth > REFLOW_CAPACITY_EPSILON) {
         const left = sorted.slice(0, selectedIndex).reverse();
         const right = sorted.slice(selectedIndex + 1);
         const restorable = (candidates) => candidates.reduce((total, module) => total + (options.restorableWidthById?.get(module.id) ?? 0), 0);
         const candidates = restorable(left) > restorable(right) ? [...left, ...right] : [...right, ...left];
         for (const module of candidates) {
-            if (remainingFreedWidth <= RUN_ADJACENCY_EPSILON)
+            if (remainingFreedWidth <= REFLOW_CAPACITY_EPSILON)
                 break;
-            const available = Math.max(0, options.restorableWidthById.get(module.id) ?? 0);
+            const available = Math.max(0, options.restorableWidthById?.get(module.id) ?? 0);
             const restoration = Math.min(available, remainingFreedWidth);
             widths.set(module.id, module.width + restoration);
             remainingFreedWidth -= restoration;
         }
+        if (preserveExtent && remainingFreedWidth > REFLOW_CAPACITY_EPSILON) {
+            const maximumWidth = options.maximumWidth ?? 1.2;
+            const fallbackCandidates = sorted
+                .map((module, index) => ({ index, module }))
+                .filter(({ module }) => module.id !== selectedId &&
+                (!options.eligibleDonorIds || options.eligibleDonorIds.has(module.id)))
+                .sort((a, b) => {
+                const distance = Math.abs(a.index - selectedIndex) - Math.abs(b.index - selectedIndex);
+                if (distance !== 0)
+                    return distance;
+                return b.index - a.index;
+            });
+            const available = fallbackCandidates.reduce((total, { module }) => {
+                const currentWidth = widths.get(module.id) ?? module.width;
+                const moduleMaximum = options.maximumWidthById?.get(module.id) ?? maximumWidth;
+                return total + Math.max(0, moduleMaximum - currentWidth);
+            }, 0);
+            if (available + REFLOW_CAPACITY_EPSILON < remainingFreedWidth)
+                return [];
+            const absorbFreedWidth = (receivers, maximumFor) => {
+                for (const { module } of receivers) {
+                    if (remainingFreedWidth <= REFLOW_CAPACITY_EPSILON)
+                        break;
+                    const currentWidth = widths.get(module.id) ?? module.width;
+                    const restoration = Math.min(Math.max(0, maximumFor(module) - currentWidth), remainingFreedWidth);
+                    widths.set(module.id, currentWidth + restoration);
+                    remainingFreedWidth -= restoration;
+                }
+            };
+            absorbFreedWidth(fallbackCandidates, (module) => options.nominalWidthById?.get(module.id) ?? module.width);
+            absorbFreedWidth(fallbackCandidates, (module) => options.maximumWidthById?.get(module.id) ?? maximumWidth);
+        }
+    }
+    const totalWidth = sorted.reduce((total, module, index) => total + (widths.get(module.id) ?? 0) + (layoutGaps[index] ?? 0), 0);
+    let nextLeft = runMinX(sorted) - consumedLeftSlack;
+    const preserveRightEdge = options.resizeSide === 'left';
+    const preserveLeftEdge = options.resizeSide === 'right';
+    if (rightConstrained && !leftConstrained) {
+        nextLeft = runMaxX(sorted) + consumedRightSlack - totalWidth;
+    }
+    else if (leftConstrained && !rightConstrained) {
+        nextLeft = runMinX(sorted) - consumedLeftSlack;
     }
-    let nextLeft = runMinX(sorted);
-    return sorted.map((module) => {
+    else if (preserveExtent && resizeSide === 'right') {
+        nextLeft = runMinX(sorted) - consumedLeftSlack;
+    }
+    else if (preserveExtent && resizeSide === 'left') {
+        nextLeft = runMaxX(sorted) + consumedRightSlack - totalWidth;
+    }
+    else if (preserveRightEdge) {
+        nextLeft = runMaxX(sorted) - totalWidth;
+    }
+    else if (preserveLeftEdge || (!leftConstrained && !rightConstrained && selectedIndex === 0)) {
+        nextLeft = preserveLeftEdge ? runMinX(sorted) - consumedLeftSlack : runMaxX(sorted) - totalWidth;
+    }
+    return sorted.map((module, index) => {
         const width = widths.get(module.id) ?? module.width;
         const position = [
             nextLeft + width / 2,
             module.position[1],
             module.position[2],
         ];
+        nextLeft += width + (layoutGaps[index] ?? 0);
+        return { id: module.id, position, width };
+    });
+}
+/**
+ * Distribute a run's existing span evenly across the requested modules. The
+ * non-requested modules keep their widths, so fixed appliances and structural
+ * fillers remain part of the run without becoming resize targets.
+ */
+export function planRunModuleWidthEqualization({ modules, equalizedIds, minimumWidthById, maximumWidthById, }) {
+    const sorted = sortRunModules(modules);
+    const targets = sorted.filter((module) => equalizedIds.has(module.id));
+    if (targets.length < 2)
+        return { ok: false, reason: 'not-enough-modules' };
+    const minX = runMinX(sorted);
+    const maxX = runMaxX(sorted);
+    const span = maxX - minX;
+    const fixedWidth = sorted
+        .filter((module) => !equalizedIds.has(module.id))
+        .reduce((total, module) => total + module.width, 0);
+    const targetWidth = (span - fixedWidth) / targets.length;
+    if (!Number.isFinite(targetWidth) || targetWidth <= REFLOW_CAPACITY_EPSILON) {
+        return { ok: false, reason: 'width-limits' };
+    }
+    for (const module of targets) {
+        const minimum = minimumWidthById?.get(module.id) ?? 0.3;
+        const maximum = maximumWidthById?.get(module.id) ?? 1.2;
+        if (targetWidth < minimum - RUN_ADJACENCY_EPSILON) {
+            return { ok: false, reason: 'width-limits' };
+        }
+        if (targetWidth > maximum + RUN_ADJACENCY_EPSILON) {
+            return { ok: false, reason: 'width-limits' };
+        }
+    }
+    let nextLeft = minX;
+    const equalizedIdList = targets.map((module) => module.id);
+    const currentById = new Map(sorted.map((module) => [module.id, module]));
+    const planned = sorted.map((module) => {
+        const width = equalizedIds.has(module.id) ? targetWidth : module.width;
+        const position = [
+            nextLeft + width / 2,
+            module.position[1],
+            module.position[2],
+        ];
         nextLeft += width;
         return { id: module.id, position, width };
     });
+    const changed = planned.some((module) => Math.abs(module.width - (currentById.get(module.id)?.width ?? 0)) > RUN_ADJACENCY_EPSILON ||
+        Math.abs(module.position[0] - (currentById.get(module.id)?.position[0] ?? 0)) >
+            RUN_ADJACENCY_EPSILON);
+    return {
+        ok: true,
+        changed,
+        targetWidth,
+        equalizedIds: equalizedIdList,
+        modules: planned,
+    };
+}
+/**
+ * Plan inserting one module at a run-local X coordinate. Existing gaps are
+ * consumed first; a full run is re-packed toward the selected push side, with
+ * only eligible filler modules allowed to donate width when both ends are
+ * wall-constrained.
+ */
+export function planRunModuleInsertion({ modules, insertion, wallConstraints, fillerIds = new Set(), minimumFillerWidth = 0.05, preserveEnd, preserveEnds, anchorInsertionSide, }) {
+    if (!Number.isFinite(insertion.width) || insertion.width <= REFLOW_CAPACITY_EPSILON) {
+        return { ok: false, reason: 'invalid-width' };
+    }
+    if (modules.some((module) => module.id === insertion.id)) {
+        return { ok: false, reason: 'duplicate-id' };
+    }
+    const sorted = sortRunModules(modules);
+    const insertionIndexAtCursor = sorted.findIndex((module) => moduleMaxX(module) > insertion.position[0] + RUN_ADJACENCY_EPSILON);
+    const normalizedIndexAtCursor = insertionIndexAtCursor < 0 ? sorted.length : insertionIndexAtCursor;
+    const leftAtCursor = sorted[normalizedIndexAtCursor - 1];
+    const rightAtCursor = sorted[normalizedIndexAtCursor];
+    const halfWidth = insertion.width / 2;
+    const anchoredInsertion = anchorInsertionSide && leftAtCursor && rightAtCursor
+        ? {
+            ...insertion,
+            position: [
+                anchorInsertionSide === 'left'
+                    ? moduleMaxX(leftAtCursor) + halfWidth
+                    : moduleMinX(rightAtCursor) - halfWidth,
+                insertion.position[1],
+                insertion.position[2],
+            ],
+        }
+        : insertion;
+    const insertionX = anchoredInsertion.position[0];
+    const normalizedIndex = normalizedIndexAtCursor;
+    const left = leftAtCursor;
+    const right = rightAtCursor;
+    const leftGap = left ? insertionX - moduleMaxX(left) : Number.POSITIVE_INFINITY;
+    const rightGap = right ? moduleMinX(right) - insertionX : Number.POSITIVE_INFINITY;
+    const fitsAtRequestedPosition = leftGap >= halfWidth - RUN_ADJACENCY_EPSILON && rightGap >= halfWidth - RUN_ADJACENCY_EPSILON;
+    if (fitsAtRequestedPosition) {
+        return {
+            ok: true,
+            inserted: anchoredInsertion,
+            modules: sorted.map((module) => ({
+                id: module.id,
+                position: module.position,
+                width: module.width,
+            })),
+            pushedSide: null,
+            shrunkFillerIds: [],
+        };
+    }
+    const preserveLeftEnd = preserveEnds?.left === true || preserveEnd === 'left';
+    const preserveRightEnd = preserveEnds?.right === true || preserveEnd === 'right';
+    const effectiveWallConstraints = {
+        left: preserveLeftEnd
+            ? { constrained: true, slack: 0 }
+            : (wallConstraints?.left ?? OPEN_RUN_END),
+        right: preserveRightEnd
+            ? { constrained: true, slack: 0 }
+            : (wallConstraints?.right ?? OPEN_RUN_END),
+    };
+    const leftConstrained = effectiveWallConstraints.left.constrained;
+    const rightConstrained = effectiveWallConstraints.right.constrained;
+    const leftCapacity = leftConstrained
+        ? Math.max(0, effectiveWallConstraints.left.slack)
+        : Number.POSITIVE_INFINITY;
+    const rightCapacity = rightConstrained
+        ? Math.max(0, effectiveWallConstraints.right.slack)
+        : Number.POSITIVE_INFINITY;
+    const pushedSide = preserveRightEnd && !preserveLeftEnd
+        ? 'left'
+        : preserveLeftEnd && !preserveRightEnd
+            ? 'right'
+            : rightCapacity > leftCapacity + RUN_ADJACENCY_EPSILON
+                ? 'right'
+                : leftCapacity > rightCapacity + RUN_ADJACENCY_EPSILON
+                    ? 'left'
+                    : rightConstrained && !leftConstrained
+                        ? 'left'
+                        : 'right';
+    const provisionalPosition = left && right
+        ? [
+            anchorInsertionSide === 'right' ? moduleMinX(right) : moduleMaxX(left),
+            anchoredInsertion.position[1],
+            anchoredInsertion.position[2],
+        ]
+        : anchoredInsertion.position;
+    const provisional = {
+        id: insertion.id,
+        position: provisionalPosition,
+        width: 0,
+    };
+    const combined = [
+        ...sorted.slice(0, normalizedIndex),
+        provisional,
+        ...sorted.slice(normalizedIndex),
+    ];
+    const reflowed = reflowRunModules(combined, insertion.id, insertion.width, {
+        wallConstraints: effectiveWallConstraints,
+        resizeSide: pushedSide,
+        consumeAdjacentGap: leftGap > RUN_ADJACENCY_EPSILON || rightGap > RUN_ADJACENCY_EPSILON,
+        adjacentGapSide: pushedSide === 'right'
+            ? leftGap > RUN_ADJACENCY_EPSILON
+                ? 'left'
+                : 'right'
+            : rightGap > RUN_ADJACENCY_EPSILON
+                ? 'right'
+                : 'left',
+        eligibleDonorIds: fillerIds,
+        minimumWidthById: new Map([...fillerIds].map((id) => [id, minimumFillerWidth])),
+    });
+    if (reflowed.length !== combined.length)
+        return { ok: false, reason: 'no-space' };
+    const plannedInserted = reflowed.find((module) => module.id === insertion.id);
+    if (!plannedInserted || plannedInserted.width <= REFLOW_CAPACITY_EPSILON) {
+        return { ok: false, reason: 'no-space' };
+    }
+    const originalWidths = new Map(sorted.map((module) => [module.id, module.width]));
+    const shrunkFillerIds = reflowed
+        .filter((module) => fillerIds.has(module.id) &&
+        module.width < (originalWidths.get(module.id) ?? module.width) - REFLOW_CAPACITY_EPSILON)
+        .map((module) => module.id);
+    return {
+        ok: true,
+        inserted: plannedInserted,
+        modules: reflowed.filter((module) => module.id !== insertion.id),
+        pushedSide,
+        shrunkFillerIds,
+    };
 }
 /** Full-run bounds in run-local frame (X along the run). */
 export function runLocalXExtent(modules) {