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

package/dist/cabinet/run-layout.d.ts

@@ -1,4 +1,4 @@
-import type { CabinetModuleNode, CabinetNode, GeometryContext } from '@pascal-app/core';
+import type { AnyNode, AnyNodeId, CabinetModuleNode, CabinetNode, GeometryContext } 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
@@ -8,13 +8,33 @@ import type { CabinetModuleNode, CabinetNode, GeometryContext } from '@pascal-ap
 export declare const RUN_ADJACENCY_EPSILON = 0.0001;
 type ModuleLike = Pick<CabinetModuleNode, 'id' | 'position' | 'width'>;
 type ReflowRunModulesOptions = {
+    wallConstraints?: RunWallConstraints;
+    resizeSide?: 'left' | 'right';
+    consumeAdjacentGap?: boolean;
+    adjacentGapSide?: 'left' | 'right';
+    eligibleDonorIds?: ReadonlySet<CabinetModuleNode['id']>;
+    maximumWidth?: number;
+    maximumWidthById?: ReadonlyMap<CabinetModuleNode['id'], number>;
     minimumWidth?: number;
-    preserveExtent?: boolean;
+    minimumWidthById?: ReadonlyMap<CabinetModuleNode['id'], number>;
+    nominalWidthById?: ReadonlyMap<CabinetModuleNode['id'], number>;
     restorableWidthById?: ReadonlyMap<CabinetModuleNode['id'], number>;
 };
+export type RunWallEndConstraint = {
+    constrained: boolean;
+    slack: number;
+};
+export type RunWallConstraints = {
+    left: RunWallEndConstraint;
+    right: RunWallEndConstraint;
+};
+type RunWallConstraintOptions = {
+    widthGrowth?: number;
+};
 export declare function sortRunModules<T extends ModuleLike>(modules: readonly T[]): T[];
 export declare function moduleMinX(module: Pick<CabinetModuleNode, 'position' | 'width'>): number;
 export declare function moduleMaxX(module: Pick<CabinetModuleNode, 'position' | 'width'>): number;
+export declare function runWallConstraints(run: Pick<CabinetNode, 'depth' | 'parentId' | 'position' | 'rotation' | 'width'>, modules: readonly ModuleLike[], nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>, options?: RunWallConstraintOptions): RunWallConstraints;
 export declare function runMinX(modules: readonly ModuleLike[]): number;
 export declare function runMaxX(modules: readonly ModuleLike[]): number;
 /**
@@ -76,14 +96,80 @@ export declare function sideInsertX({ anchorModule, modules, side, width, epsilo
     epsilon?: number;
 }): number | null;
 /**
- * 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 declare function reflowRunModules<T extends ModuleLike>(modules: readonly T[], selectedId: CabinetModuleNode['id'], selectedWidth: number, options?: ReflowRunModulesOptions): Array<{
     id: T['id'];
     position: T['position'];
     width: number;
 }>;
+export type RunModuleWidthEqualizationPlan<T extends ModuleLike> = {
+    ok: true;
+    changed: boolean;
+    targetWidth: number;
+    equalizedIds: T['id'][];
+    modules: Array<{
+        id: T['id'];
+        position: T['position'];
+        width: number;
+    }>;
+} | {
+    ok: false;
+    reason: 'not-enough-modules' | 'width-limits';
+};
+/**
+ * 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 declare function planRunModuleWidthEqualization<T extends ModuleLike>({ modules, equalizedIds, minimumWidthById, maximumWidthById, }: {
+    modules: readonly T[];
+    equalizedIds: ReadonlySet<T['id']>;
+    minimumWidthById?: ReadonlyMap<T['id'], number>;
+    maximumWidthById?: ReadonlyMap<T['id'], number>;
+}): RunModuleWidthEqualizationPlan<T>;
+export type RunModuleInsertionPlan<T extends ModuleLike> = {
+    ok: true;
+    inserted: {
+        id: T['id'];
+        position: T['position'];
+        width: number;
+    };
+    modules: Array<{
+        id: T['id'];
+        position: T['position'];
+        width: number;
+    }>;
+    pushedSide: 'left' | 'right' | null;
+    shrunkFillerIds: T['id'][];
+} | {
+    ok: false;
+    reason: 'invalid-width' | 'duplicate-id' | 'no-space';
+};
+/**
+ * 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 declare function planRunModuleInsertion<T extends ModuleLike>({ modules, insertion, wallConstraints, fillerIds, minimumFillerWidth, preserveEnd, preserveEnds, anchorInsertionSide, }: {
+    modules: readonly T[];
+    insertion: {
+        id: T['id'];
+        position: T['position'];
+        width: number;
+    };
+    wallConstraints?: RunWallConstraints;
+    fillerIds?: ReadonlySet<T['id']>;
+    minimumFillerWidth?: number;
+    preserveEnd?: 'left' | 'right';
+    preserveEnds?: Partial<Record<'left' | 'right', boolean>>;
+    anchorInsertionSide?: 'left' | 'right';
+}): RunModuleInsertionPlan<T>;
 /** Full-run bounds in run-local frame (X along the run). */
 export declare function runLocalXExtent(modules: readonly ModuleLike[]): {
     minX: number;

package/dist/cabinet/run-layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-layout.d.ts","sourceRoot":"","sources":["../../src/cabinet/run-layout.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"run-layout.d.ts","sourceRoot":"","sources":["../../src/cabinet/run-layout.ts"],"names":[],"mappings":"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"}

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));
 }
@@ -282,8 +377,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 +391,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;
+    }
+    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;
     }
-    let nextLeft = runMinX(sorted);
-    return sorted.map((module) => {
+    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) {