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

package/dist/cabinet/validation.d.ts

@@ -0,0 +1,27 @@
+import type { AnyNode, AnyNodeId, CabinetModuleNode, CabinetNode } from '@pascal-app/core';
+export declare const CABINET_PLANNING_TOLERANCE = 0.0001;
+export declare const MIN_PRACTICAL_TOP_CABINET_HEIGHT = 0.15;
+export type CabinetPlanningIssueCode = 'module-overlap' | 'module-gap' | 'tier-mismatch' | 'stack-too-short' | 'top-cabinet-too-short' | 'ceiling-overflow';
+export type CabinetPlanningIssue = {
+    code: CabinetPlanningIssueCode;
+    severity: 'error' | 'warning';
+    message: string;
+    nodeIds: string[];
+};
+export type CabinetPlanningReport = {
+    valid: boolean;
+    errors: CabinetPlanningIssue[];
+    warnings: CabinetPlanningIssue[];
+};
+export type CabinetPlanningOptions = {
+    tolerance?: number;
+    minimumTopCabinetHeight?: number;
+    nodes?: Readonly<Partial<Record<AnyNodeId, AnyNode>>>;
+};
+/**
+ * Validate the structural rules shared by cabinet-run editing, previews, and
+ * export. This is intentionally scene-independent: callers resolve a run's
+ * module children and pass the same values used to build the run geometry.
+ */
+export declare function validateCabinetRun(run: CabinetNode, modules: readonly CabinetModuleNode[], options?: CabinetPlanningOptions): CabinetPlanningReport;
+//# sourceMappingURL=validation.d.ts.map

package/dist/cabinet/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/cabinet/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAK1F,eAAO,MAAM,0BAA0B,SAAO,CAAA;AAC9C,eAAO,MAAM,gCAAgC,OAAO,CAAA;AAEpD,MAAM,MAAM,wBAAwB,GAChC,gBAAgB,GAChB,YAAY,GACZ,eAAe,GACf,iBAAiB,GACjB,uBAAuB,GACvB,kBAAkB,CAAA;AAEtB,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,wBAAwB,CAAA;IAC9B,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,oBAAoB,EAAE,CAAA;IAC9B,QAAQ,EAAE,oBAAoB,EAAE,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,KAAK,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;CACtD,CAAA;AAeD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,SAAS,iBAAiB,EAAE,EACrC,OAAO,GAAE,sBAA2B,GACnC,qBAAqB,CA6FvB"}

package/dist/cabinet/validation.js

@@ -0,0 +1,56 @@
+import { moduleMaxX, moduleMinX, sortRunModules } from './run-layout';
+import { cabinetModuleCeilingOverflow } from './run-ops';
+import { minCabinetCarcassHeightForStack } from './stack';
+export const CABINET_PLANNING_TOLERANCE = 1e-4;
+export const MIN_PRACTICAL_TOP_CABINET_HEIGHT = 0.15;
+function issue(code, severity, message, nodeIds) {
+    return { code, severity, message, nodeIds };
+}
+function isFiller(module) {
+    return module.moduleKind === 'corner-filler';
+}
+/**
+ * Validate the structural rules shared by cabinet-run editing, previews, and
+ * export. This is intentionally scene-independent: callers resolve a run's
+ * module children and pass the same values used to build the run geometry.
+ */
+export function validateCabinetRun(run, modules, options = {}) {
+    const tolerance = options.tolerance ?? CABINET_PLANNING_TOLERANCE;
+    const minimumTopCabinetHeight = options.minimumTopCabinetHeight ?? MIN_PRACTICAL_TOP_CABINET_HEIGHT;
+    const errors = [];
+    const warnings = [];
+    const sorted = sortRunModules(modules);
+    for (let index = 0; index < sorted.length; index += 1) {
+        const module = sorted[index];
+        const next = sorted[index + 1];
+        const minimumStackHeight = minCabinetCarcassHeightForStack(module);
+        if (module.carcassHeight + tolerance < minimumStackHeight) {
+            errors.push(issue('stack-too-short', 'error', `${module.name || 'Cabinet module'} is shorter than its fixed compartment stack.`, [module.id]));
+        }
+        if (run.runTier === 'tall' && module.cabinetType !== 'tall') {
+            errors.push(issue('tier-mismatch', 'error', `${module.name || 'Cabinet module'} must be a tall module in a tall run.`, [run.id, module.id]));
+        }
+        else if (run.runTier === 'wall' && module.cabinetType === 'tall') {
+            errors.push(issue('tier-mismatch', 'error', `${module.name || 'Cabinet module'} cannot be a tall module in a wall run.`, [run.id, module.id]));
+        }
+        if (module.topFinish === 'top-cabinet' && module.topFinishHeight < minimumTopCabinetHeight) {
+            warnings.push(issue('top-cabinet-too-short', 'warning', `${module.name || 'Top cabinet'} is too short to be practical storage; use trim instead.`, [module.id]));
+        }
+        if (options.nodes) {
+            const overflow = cabinetModuleCeilingOverflow(module, options.nodes);
+            if (overflow > tolerance) {
+                warnings.push(issue('ceiling-overflow', 'warning', `${module.name || 'Cabinet module'} extends ${(overflow * 1000).toFixed(0)} mm above the ceiling.`, [run.id, module.id]));
+            }
+        }
+        if (!next)
+            continue;
+        const gap = moduleMinX(next) - moduleMaxX(module);
+        if (gap < -tolerance) {
+            errors.push(issue('module-overlap', 'error', `${module.name || 'Cabinet module'} overlaps ${next.name || 'the next cabinet module'}.`, [module.id, next.id]));
+        }
+        else if (gap > tolerance && !isFiller(module) && !isFiller(next)) {
+            warnings.push(issue('module-gap', 'warning', `There is an unfilled ${(gap * 1000).toFixed(0)} mm gap between cabinet modules.`, [module.id, next.id]));
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}

package/dist/cabinet/wall-height-presets.d.ts

@@ -0,0 +1,12 @@
+import type { CabinetNode } from '@pascal-app/core';
+export type CabinetWallHeightPresetId = '18' | '24' | '30' | '36' | '42';
+export type CabinetWallHeightPreset = {
+    id: CabinetWallHeightPresetId;
+    label: string;
+    metricLabel: string;
+    value: number;
+};
+export declare const CABINET_WALL_HEIGHT_PRESETS: CabinetWallHeightPreset[];
+export declare function cabinetWallHeightPresetId(node: Pick<CabinetNode, 'carcassHeight'> | number): CabinetWallHeightPresetId | 'custom';
+export declare function cabinetWallHeightPresetById(id: CabinetWallHeightPresetId): CabinetWallHeightPreset;
+//# sourceMappingURL=wall-height-presets.d.ts.map

package/dist/cabinet/wall-height-presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-height-presets.d.ts","sourceRoot":"","sources":["../../src/cabinet/wall-height-presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD,MAAM,MAAM,yBAAyB,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAExE,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,yBAAyB,CAAA;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,2BAA2B,EAAE,uBAAuB,EAMhE,CAAA;AAID,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,eAAe,CAAC,GAAG,MAAM,GAChD,yBAAyB,GAAG,QAAQ,CAOtC;AAED,wBAAgB,2BAA2B,CACzC,EAAE,EAAE,yBAAyB,GAC5B,uBAAuB,CAEzB"}

package/dist/cabinet/wall-height-presets.js

@@ -0,0 +1,15 @@
+export const CABINET_WALL_HEIGHT_PRESETS = [
+    { id: '18', label: '18″', metricLabel: '457 mm', value: 0.4572 },
+    { id: '24', label: '24″', metricLabel: '610 mm', value: 0.6096 },
+    { id: '30', label: '30″', metricLabel: '762 mm', value: 0.762 },
+    { id: '36', label: '36″', metricLabel: '914 mm', value: 0.9144 },
+    { id: '42', label: '42″', metricLabel: '1,067 mm', value: 1.0668 },
+];
+const WALL_HEIGHT_MATCH_TOLERANCE = 1e-4;
+export function cabinetWallHeightPresetId(node) {
+    const height = typeof node === 'number' ? node : node.carcassHeight;
+    return (CABINET_WALL_HEIGHT_PRESETS.find((preset) => Math.abs(preset.value - height) <= WALL_HEIGHT_MATCH_TOLERANCE)?.id ?? 'custom');
+}
+export function cabinetWallHeightPresetById(id) {
+    return CABINET_WALL_HEIGHT_PRESETS.find((preset) => preset.id === id);
+}

package/dist/cabinet/wall-snap.d.ts

@@ -15,6 +15,18 @@ export type CabinetWallSnapPlacement = {
         end: [number, number, number];
     };
 };
+export type CabinetRunWallSnapPose = {
+    position: [number, number, number];
+    rotation: number;
+};
+export declare function findClosestCabinetWallInPlan({ excludeIds, fallbackToAnyYaw, nodes, parentLevelId, planPoint, yaw, }: {
+    excludeIds: readonly AnyNodeId[];
+    fallbackToAnyYaw?: boolean;
+    nodes: Record<AnyNodeId, AnyNode>;
+    parentLevelId: AnyNodeId;
+    planPoint: readonly [number, number];
+    yaw?: number;
+}): WallHit | null;
 export declare function resolveCabinetWallFaceOffset({ hit, nodes, parentLevelId, }: {
     hit: WallHit;
     nodes: Record<AnyNodeId, AnyNode>;
@@ -27,12 +39,23 @@ export declare function collectCabinetWallSnapNeighbors({ hit, nodes, excludeIds
     parentLevelId: AnyNodeId;
     width: number;
 }): CabinetWallSnapNeighbor[];
-export declare function resolveCabinetWallSnapPlacement({ depth, gridStep, faceOffset, hit, neighbors, width, }: {
+export declare function resolveCabinetWallSnapPlacement({ depth, gridStep, faceOffset, hit, endStop, neighbors, startStop, width, }: {
     depth: number;
+    endStop?: number;
     faceOffset?: number;
     gridStep?: number;
     hit: WallHit;
     neighbors?: CabinetWallSnapNeighbor[];
+    startStop?: number;
+    width: number;
+}): CabinetWallSnapPlacement | null;
+export declare function resolveCabinetWallSnapPlacementInScene({ depth, excludeIds, gridStep, hit, nodes, parentLevelId, width, }: {
+    depth: number;
+    excludeIds?: readonly AnyNodeId[];
+    gridStep?: number;
+    hit: WallHit;
+    nodes: Record<AnyNodeId, AnyNode>;
+    parentLevelId: AnyNodeId;
     width: number;
 }): CabinetWallSnapPlacement | null;
 /**
@@ -53,14 +76,15 @@ export declare function resolveCabinetModuleWallSnapLocal({ candidateLocal, excl
         type: 'cabinet';
     }>;
 }): [number, number, number] | null;
-export declare function resolveCabinetRunWallSnap({ cabinet, candidatePosition, excludeIds, gridStep, nodes, parentLevelId, }: {
+export declare function resolveCabinetRunWallSnap({ cabinet, candidatePosition, candidateRotation, excludeIds, gridStep, nodes, parentLevelId, }: {
     cabinet: Extract<AnyNode, {
         type: 'cabinet';
     }>;
     candidatePosition: [number, number, number];
+    candidateRotation?: number;
     excludeIds?: readonly AnyNodeId[];
     gridStep?: number;
     nodes: Record<AnyNodeId, AnyNode>;
     parentLevelId: AnyNodeId;
-}): [number, number, number] | null;
+}): CabinetRunWallSnapPose | null;
 //# sourceMappingURL=wall-snap.d.ts.map

package/dist/cabinet/wall-snap.d.ts.map

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

package/dist/cabinet/wall-snap.js

@@ -1,21 +1,22 @@
-import { calculateLevelMiters, getWallPlanFootprint, getWallThickness, } from '@pascal-app/core';
-import { findClosestWallInPlan, projectWallLocalPointToPlan } from '../shared/wall-attach-target';
+import { calculateLevelMiters, getWallArcData, getWallCurveFrameAt, getWallPlanFootprint, getWallThickness, isCurvedWall, WALL_SNAP_DISTANCE_M, } from '@pascal-app/core';
 import { snapCabinetFootprintCenter } from './placement-snap';
 import { planToRunLocal, runLocalToPlan } from './run-layout';
 const EDGE_SNAP_THRESHOLD = 0.08;
 const FACE_MATCH_THRESHOLD = 0.12;
 const YAW_MATCH_THRESHOLD = 0.08;
 const WALL_FACE_EPSILON = 1e-5;
+const WALL_JUNCTION_EPSILON = 0.001;
 function angleDelta(a, b) {
     return Math.atan2(Math.sin(a - b), Math.cos(a - b));
 }
-function snapLocalXToStops({ localX, neighbors, wallLength, width, }) {
-    if (wallLength <= width)
-        return { localX: wallLength / 2, reason: 'corner' };
+function snapLocalXToStops({ endStop, localX, neighbors, startStop, width, }) {
+    if (endStop - startStop <= width) {
+        return { localX: (startStop + endStop) / 2, reason: 'corner' };
+    }
     const halfWidth = width / 2;
     const stops = [
-        { value: 0, reason: 'corner' },
-        { value: wallLength, reason: 'corner' },
+        { value: startStop, reason: 'corner' },
+        { value: endStop, reason: 'corner' },
     ];
     for (const neighbor of neighbors) {
         stops.push({ value: neighbor.minX, reason: 'cabinet-edge' }, { value: neighbor.maxX, reason: 'cabinet-edge' });
@@ -25,8 +26,9 @@ function snapLocalXToStops({ localX, neighbors, wallLength, width, }) {
         for (const stop of stops) {
             const delta = stop.value - movingStop;
             const candidateLocalX = localX + delta;
-            if (candidateLocalX < halfWidth || candidateLocalX > wallLength - halfWidth)
+            if (candidateLocalX < startStop + halfWidth || candidateLocalX > endStop - halfWidth) {
                 continue;
+            }
             const distance = Math.abs(delta);
             if (distance > EDGE_SNAP_THRESHOLD)
                 continue;
@@ -37,6 +39,204 @@ function snapLocalXToStops({ localX, neighbors, wallLength, width, }) {
     }
     return best ? { localX: best.localX, reason: best.reason } : { localX, reason: 'grid' };
 }
+function normalizePositiveAngle(angle) {
+    const fullTurn = Math.PI * 2;
+    return ((angle % fullTurn) + fullTurn) % fullTurn;
+}
+function closestCurvedWallPoint(wall, planPoint) {
+    const arc = getWallArcData(wall);
+    if (!arc)
+        return null;
+    const queryAngle = Math.atan2(planPoint[1] - arc.center.y, planPoint[0] - arc.center.x);
+    const sweep = Math.abs(arc.delta);
+    const progress = arc.delta > 0
+        ? normalizePositiveAngle(queryAngle - arc.startAngle)
+        : normalizePositiveAngle(arc.startAngle - queryAngle);
+    let t;
+    if (progress <= sweep) {
+        t = progress / sweep;
+    }
+    else {
+        const start = getWallCurveFrameAt(wall, 0).point;
+        const end = getWallCurveFrameAt(wall, 1).point;
+        const startDistance = Math.hypot(planPoint[0] - start.x, planPoint[1] - start.y);
+        const endDistance = Math.hypot(planPoint[0] - end.x, planPoint[1] - end.y);
+        t = startDistance <= endDistance ? 0 : 1;
+    }
+    const frame = getWallCurveFrameAt(wall, t);
+    const dx = planPoint[0] - frame.point.x;
+    const dz = planPoint[1] - frame.point.y;
+    return {
+        wall,
+        localX: t * arc.radius * sweep,
+        perpDistance: dx * frame.normal.x + dz * frame.normal.y,
+        dirX: frame.tangent.x,
+        dirY: frame.tangent.y,
+        wallLength: arc.radius * sweep,
+        distance: Math.hypot(dx, dz),
+    };
+}
+function closestStraightWallPoint(wall, planPoint) {
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const wallLength = Math.hypot(dx, dz);
+    if (wallLength <= 1e-6)
+        return null;
+    const dirX = dx / wallLength;
+    const dirY = dz / wallLength;
+    const fromStartX = planPoint[0] - wall.start[0];
+    const fromStartZ = planPoint[1] - wall.start[1];
+    const localX = Math.max(0, Math.min(wallLength, fromStartX * dirX + fromStartZ * dirY));
+    const closestX = wall.start[0] + dirX * localX;
+    const closestZ = wall.start[1] + dirY * localX;
+    return {
+        wall,
+        localX,
+        perpDistance: fromStartX * -dirY + fromStartZ * dirX,
+        dirX,
+        dirY,
+        wallLength,
+        distance: Math.hypot(planPoint[0] - closestX, planPoint[1] - closestZ),
+    };
+}
+export function findClosestCabinetWallInPlan({ excludeIds, fallbackToAnyYaw = false, nodes, parentLevelId, planPoint, yaw, }) {
+    const excluded = new Set(excludeIds);
+    let bestAny;
+    let bestCompatible;
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'wall' || node.parentId !== parentLevelId)
+            continue;
+        const wall = node;
+        if (excluded.has(wall.id))
+            continue;
+        const closest = isCurvedWall(wall)
+            ? closestCurvedWallPoint(wall, planPoint)
+            : closestStraightWallPoint(wall, planPoint);
+        if (!closest || closest.distance > WALL_SNAP_DISTANCE_M)
+            continue;
+        const side = closest.perpDistance >= 0 ? 'front' : 'back';
+        const candidate = {
+            distance: closest.distance,
+            hit: {
+                wall,
+                localX: closest.localX,
+                perpDistance: closest.perpDistance,
+                side,
+                dirX: closest.dirX,
+                dirY: closest.dirY,
+                wallLength: closest.wallLength,
+                itemRotation: side === 'front' ? 0 : Math.PI,
+            },
+        };
+        if (!bestAny || candidate.distance < bestAny.distance)
+            bestAny = candidate;
+        if (yaw !== undefined &&
+            Math.abs(Math.sin(yaw + Math.atan2(closest.dirY, closest.dirX))) <=
+                Math.sin(YAW_MATCH_THRESHOLD) &&
+            (!bestCompatible || candidate.distance < bestCompatible.distance)) {
+            bestCompatible = candidate;
+        }
+    }
+    if (yaw === undefined)
+        return bestAny?.hit ?? null;
+    return bestCompatible?.hit ?? (fallbackToAnyYaw ? (bestAny?.hit ?? null) : null);
+}
+function cabinetWallFrameAtLocalX(hit, localX) {
+    if (isCurvedWall(hit.wall)) {
+        return getWallCurveFrameAt(hit.wall, localX / hit.wallLength);
+    }
+    return {
+        point: {
+            x: hit.wall.start[0] + hit.dirX * localX,
+            y: hit.wall.start[1] + hit.dirY * localX,
+        },
+        tangent: { x: hit.dirX, y: hit.dirY },
+        normal: { x: -hit.dirY, y: hit.dirX },
+    };
+}
+function projectCabinetWallLocalPointToPlan(hit, localX, localZ = 0) {
+    const frame = cabinetWallFrameAtLocalX(hit, localX);
+    return [frame.point.x + frame.normal.x * localZ, frame.point.y + frame.normal.y * localZ];
+}
+function pointsMeet(a, b) {
+    return Math.hypot(a[0] - b[0], a[1] - b[1]) <= WALL_JUNCTION_EPSILON;
+}
+function polygonXExtentWithinZBand(points, zA, zB) {
+    const minZ = Math.min(zA, zB);
+    const maxZ = Math.max(zA, zB);
+    const xs = [];
+    for (let index = 0; index < points.length; index += 1) {
+        const a = points[index];
+        const b = points[(index + 1) % points.length];
+        if (a.z >= minZ - WALL_FACE_EPSILON && a.z <= maxZ + WALL_FACE_EPSILON)
+            xs.push(a.x);
+        const dz = b.z - a.z;
+        if (Math.abs(dz) <= WALL_FACE_EPSILON)
+            continue;
+        for (const boundary of [minZ, maxZ]) {
+            const t = (boundary - a.z) / dz;
+            if (t >= -WALL_FACE_EPSILON && t <= 1 + WALL_FACE_EPSILON) {
+                xs.push(a.x + (b.x - a.x) * t);
+            }
+        }
+    }
+    return xs.length > 0 ? { minX: Math.min(...xs), maxX: Math.max(...xs) } : null;
+}
+function resolveCabinetWallUsableSpan({ depth, excludeIds, hit, nodes, parentLevelId, }) {
+    if (isCurvedWall(hit.wall))
+        return { start: 0, end: hit.wallLength };
+    const walls = Object.values(nodes).filter((node) => node?.type === 'wall' && node.parentId === parentLevelId);
+    const miterData = calculateLevelMiters(walls);
+    const excluded = new Set(excludeIds);
+    const frontNormal = [-hit.dirY, hit.dirX];
+    const normalScale = hit.side === 'front' ? 1 : -1;
+    const faceZ = normalScale * (getWallThickness(hit.wall) / 2);
+    const outerZ = faceZ + normalScale * depth;
+    let start = 0;
+    let end = hit.wallLength;
+    for (const wall of walls) {
+        if (wall.id === hit.wall.id || excluded.has(wall.id))
+            continue;
+        const connectedAtStart = pointsMeet(hit.wall.start, wall.start)
+            ? wall.end
+            : pointsMeet(hit.wall.start, wall.end)
+                ? wall.start
+                : null;
+        const connectedAtEnd = pointsMeet(hit.wall.end, wall.start)
+            ? wall.end
+            : pointsMeet(hit.wall.end, wall.end)
+                ? wall.start
+                : null;
+        const farPoint = connectedAtStart ?? connectedAtEnd;
+        if (!farPoint)
+            continue;
+        const connectionPoint = connectedAtStart ? hit.wall.start : hit.wall.end;
+        const farDx = farPoint[0] - connectionPoint[0];
+        const farDz = farPoint[1] - connectionPoint[1];
+        const returnSide = farDx * frontNormal[0] + farDz * frontNormal[1];
+        if (returnSide * normalScale <= WALL_JUNCTION_EPSILON)
+            continue;
+        const localFootprint = getWallPlanFootprint(wall, miterData).map((point) => {
+            const dx = point.x - hit.wall.start[0];
+            const dz = point.y - hit.wall.start[1];
+            return {
+                x: dx * hit.dirX + dz * hit.dirY,
+                z: dx * frontNormal[0] + dz * frontNormal[1],
+            };
+        });
+        const extent = polygonXExtentWithinZBand(localFootprint, faceZ, outerZ);
+        if (!extent)
+            continue;
+        if (connectedAtStart)
+            start = Math.max(start, extent.maxX);
+        else
+            end = Math.min(end, extent.minX);
+    }
+    return {
+        start: Math.min(hit.wallLength, Math.max(0, start)),
+        end: Math.max(0, Math.min(hit.wallLength, end)),
+    };
+}
 function cabinetRunWidthAndCenterOffset(cabinet, nodes) {
     const modules = (cabinet.children ?? [])
         .map((id) => nodes[id])
@@ -48,6 +248,9 @@ function cabinetRunWidthAndCenterOffset(cabinet, nodes) {
     return { width: Math.max(0.01, maxX - minX), centerOffset: (minX + maxX) / 2 };
 }
 export function resolveCabinetWallFaceOffset({ hit, nodes, parentLevelId, }) {
+    if (isCurvedWall(hit.wall)) {
+        return (hit.side === 'front' ? 1 : -1) * (getWallThickness(hit.wall) / 2);
+    }
     const walls = Object.values(nodes).filter((node) => node?.type === 'wall' && node.parentId === parentLevelId);
     if (walls.length === 0) {
         return (hit.side === 'front' ? 1 : -1) * (getWallThickness(hit.wall) / 2);
@@ -93,6 +296,8 @@ export function resolveCabinetWallFaceOffset({ hit, nodes, parentLevelId, }) {
     return hit.side === 'front' ? Math.max(...zIntersections) : Math.min(...zIntersections);
 }
 export function collectCabinetWallSnapNeighbors({ hit, nodes, excludeIds = [], parentLevelId, width, }) {
+    if (isCurvedWall(hit.wall))
+        return [];
     const frontNormal = [-hit.dirY, hit.dirX];
     const normalScale = hit.side === 'front' ? 1 : -1;
     const yaw = Math.atan2(frontNormal[0] * normalScale, frontNormal[1] * normalScale);
@@ -127,30 +332,32 @@ export function collectCabinetWallSnapNeighbors({ hit, nodes, excludeIds = [], p
     }
     return neighbors;
 }
-export function resolveCabinetWallSnapPlacement({ depth, gridStep = 0, faceOffset, hit, neighbors = [], width, }) {
-    if (hit.wallLength <= 1e-6)
+export function resolveCabinetWallSnapPlacement({ depth, gridStep = 0, faceOffset, hit, endStop = hit.wallLength, neighbors = [], startStop = 0, width, }) {
+    if (hit.wallLength <= 1e-6 || endStop <= startStop)
         return null;
     const halfWidth = width / 2;
     const snappedLocalX = snapCabinetFootprintCenter(hit.localX, width, gridStep);
-    const clampedLocalX = hit.wallLength > width
-        ? Math.min(hit.wallLength - halfWidth, Math.max(halfWidth, snappedLocalX))
-        : hit.wallLength / 2;
+    const clampedLocalX = endStop - startStop > width
+        ? Math.min(endStop - halfWidth, Math.max(startStop + halfWidth, snappedLocalX))
+        : (startStop + endStop) / 2;
     const snapped = snapLocalXToStops({
+        endStop,
         localX: clampedLocalX,
         neighbors,
-        wallLength: hit.wallLength,
+        startStop,
         width,
     });
     const localX = snapped.localX;
-    const centerline = projectWallLocalPointToPlan(hit.wall, localX);
-    const frontNormal = [-hit.dirY, hit.dirX];
+    const frame = cabinetWallFrameAtLocalX(hit, localX);
+    const centerline = [frame.point.x, frame.point.y];
+    const frontNormal = [frame.normal.x, frame.normal.y];
     const normalScale = hit.side === 'front' ? 1 : -1;
     const normal = [frontNormal[0] * normalScale, frontNormal[1] * normalScale];
     const resolvedFaceOffset = faceOffset ?? (normalScale * getWallThickness(hit.wall)) / 2;
     const cabinetCenterOffset = resolvedFaceOffset + normalScale * (depth / 2);
     const guideOffset = resolvedFaceOffset;
-    const guideStart = projectWallLocalPointToPlan(hit.wall, Math.max(0, localX - halfWidth), guideOffset);
-    const guideEnd = projectWallLocalPointToPlan(hit.wall, Math.min(hit.wallLength, localX + halfWidth), guideOffset);
+    const guideStart = projectCabinetWallLocalPointToPlan(hit, Math.max(startStop, localX - halfWidth), guideOffset);
+    const guideEnd = projectCabinetWallLocalPointToPlan(hit, Math.min(endStop, localX + halfWidth), guideOffset);
     return {
         position: [
             centerline[0] + frontNormal[0] * cabinetCenterOffset,
@@ -167,6 +374,25 @@ export function resolveCabinetWallSnapPlacement({ depth, gridStep = 0, faceOffse
         },
     };
 }
+export function resolveCabinetWallSnapPlacementInScene({ depth, excludeIds = [], gridStep = 0, hit, nodes, parentLevelId, width, }) {
+    const span = resolveCabinetWallUsableSpan({ depth, excludeIds, hit, nodes, parentLevelId });
+    return resolveCabinetWallSnapPlacement({
+        depth,
+        endStop: span.end,
+        faceOffset: resolveCabinetWallFaceOffset({ hit, nodes, parentLevelId }),
+        gridStep,
+        hit,
+        neighbors: collectCabinetWallSnapNeighbors({
+            excludeIds,
+            hit,
+            nodes,
+            parentLevelId,
+            width,
+        }),
+        startStop: span.start,
+        width,
+    });
+}
 /**
  * Wall snap for a single dragged module, in its run's LOCAL frame — the
  * frame `movable.parentFrame` kinds store `position` in. Converts the
@@ -176,76 +402,66 @@ export function resolveCabinetWallSnapPlacement({ depth, gridStep = 0, faceOffse
  */
 export function resolveCabinetModuleWallSnapLocal({ candidateLocal, excludeIds = [], gridStep = 0, module, nodes, parentLevelId, run, }) {
     const planCenter = runLocalToPlan(run, candidateLocal);
-    const hit = findClosestWallInPlan([planCenter[0], planCenter[2]], nodes, parentLevelId);
+    const worldYaw = run.rotation + module.rotation;
+    const hit = findClosestCabinetWallInPlan({
+        excludeIds,
+        nodes,
+        parentLevelId,
+        planPoint: [planCenter[0], planCenter[2]],
+        yaw: worldYaw,
+    });
     if (!hit)
         return null;
-    if (excludeIds.includes(hit.wall.id))
-        return null;
-    const faceOffset = resolveCabinetWallFaceOffset({ hit, nodes, parentLevelId });
-    const placement = resolveCabinetWallSnapPlacement({
+    const placement = resolveCabinetWallSnapPlacementInScene({
         depth: module.depth,
-        faceOffset,
+        excludeIds: [...excludeIds, run.id],
         gridStep,
         hit,
-        neighbors: collectCabinetWallSnapNeighbors({
-            hit,
-            nodes,
-            // The moving module's own run must not offer edge stops — its span
-            // still includes the module's pre-drag position.
-            excludeIds: [...excludeIds, run.id],
-            parentLevelId,
-            width: module.width,
-        }),
+        nodes,
+        parentLevelId,
         width: module.width,
     });
     if (!placement)
         return null;
-    const worldYaw = run.rotation + module.rotation;
     if (Math.abs(angleDelta(worldYaw, placement.yaw)) > YAW_MATCH_THRESHOLD)
         return null;
     return planToRunLocal(run, placement.position[0], candidateLocal[1], placement.position[2]);
 }
-export function resolveCabinetRunWallSnap({ cabinet, candidatePosition, excludeIds = [], gridStep = 0, nodes, parentLevelId, }) {
+export function resolveCabinetRunWallSnap({ cabinet, candidatePosition, candidateRotation = cabinet.rotation, excludeIds = [], gridStep = 0, nodes, parentLevelId, }) {
     const run = cabinetRunWidthAndCenterOffset(cabinet, nodes);
-    const axisX = Math.cos(cabinet.rotation);
-    const axisZ = -Math.sin(cabinet.rotation);
+    const axisX = Math.cos(candidateRotation);
+    const axisZ = -Math.sin(candidateRotation);
     const footprintCenter = [
         candidatePosition[0] + axisX * run.centerOffset,
         candidatePosition[2] + axisZ * run.centerOffset,
     ];
-    const hit = findClosestWallInPlan(footprintCenter, nodes, parentLevelId);
-    if (!hit)
-        return null;
-    // A wall moving with the same group (whole-room drag) still sits at its
-    // pre-drag position in `nodes` — snapping to it would tear the group apart.
-    if (excludeIds.includes(hit.wall.id))
-        return null;
-    const faceOffset = resolveCabinetWallFaceOffset({
-        hit,
+    const hit = findClosestCabinetWallInPlan({
+        excludeIds,
+        fallbackToAnyYaw: true,
         nodes,
         parentLevelId,
+        planPoint: footprintCenter,
+        yaw: candidateRotation,
     });
-    const placement = resolveCabinetWallSnapPlacement({
+    if (!hit)
+        return null;
+    const placement = resolveCabinetWallSnapPlacementInScene({
         depth: cabinet.depth,
-        faceOffset,
+        excludeIds,
         gridStep,
         hit,
-        neighbors: collectCabinetWallSnapNeighbors({
-            hit,
-            nodes,
-            excludeIds,
-            parentLevelId,
-            width: run.width,
-        }),
+        nodes,
+        parentLevelId,
         width: run.width,
     });
     if (!placement)
         return null;
-    if (Math.abs(angleDelta(cabinet.rotation, placement.yaw)) > YAW_MATCH_THRESHOLD)
-        return null;
-    return [
-        placement.position[0] - Math.cos(placement.yaw) * run.centerOffset,
-        candidatePosition[1],
-        placement.position[2] + Math.sin(placement.yaw) * run.centerOffset,
-    ];
+    return {
+        position: [
+            placement.position[0] - Math.cos(placement.yaw) * run.centerOffset,
+            candidatePosition[1],
+            placement.position[2] + Math.sin(placement.yaw) * run.centerOffset,
+        ],
+        rotation: placement.yaw,
+    };
 }

package/dist/cabinet/widths.d.ts

@@ -0,0 +1,10 @@
+export type CabinetStandardWidthId = '300' | '400' | '600' | '800';
+export type CabinetStandardWidth = {
+    id: CabinetStandardWidthId;
+    label: string;
+    value: number;
+};
+export declare const CABINET_STANDARD_WIDTHS: CabinetStandardWidth[];
+export declare function cabinetStandardWidthId(width: number): CabinetStandardWidthId | 'custom';
+export declare function cabinetStandardWidthById(id: CabinetStandardWidthId): CabinetStandardWidth;
+//# sourceMappingURL=widths.d.ts.map

package/dist/cabinet/widths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widths.d.ts","sourceRoot":"","sources":["../../src/cabinet/widths.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,sBAAsB,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAA;AAElE,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,sBAAsB,CAAA;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,EAKzD,CAAA;AAID,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB,GAAG,QAAQ,CAMvF;AAED,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,sBAAsB,GAAG,oBAAoB,CAEzF"}