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

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"}

package/dist/cabinet/widths.js

@@ -0,0 +1,13 @@
+export const CABINET_STANDARD_WIDTHS = [
+    { id: '300', label: '300 mm', value: 0.3 },
+    { id: '400', label: '400 mm', value: 0.4 },
+    { id: '600', label: '600 mm', value: 0.6 },
+    { id: '800', label: '800 mm', value: 0.8 },
+];
+const WIDTH_MATCH_TOLERANCE = 1e-4;
+export function cabinetStandardWidthId(width) {
+    return (CABINET_STANDARD_WIDTHS.find((candidate) => Math.abs(candidate.value - width) <= WIDTH_MATCH_TOLERANCE)?.id ?? 'custom');
+}
+export function cabinetStandardWidthById(id) {
+    return CABINET_STANDARD_WIDTHS.find((candidate) => candidate.id === id);
+}

package/dist/ceiling/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ceiling/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AAiBzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAmFtC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CA2GhE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ceiling/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AAmBzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAmFtC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAiHhE,CAAA"}

package/dist/ceiling/definition.js

@@ -1,5 +1,5 @@
 import { getCeilingClampBound, resolveCeilingHeight, useScene, } from '@pascal-app/core';
-import { clearStructuralElevationGuide, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { clearStructuralElevationGuide, DRAFTING_SURFACE_EXTENSION_KEY, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
 import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
 import { buildCeilingFloorplan } from './floorplan';
 import { ceilingAddVertexAffordance, ceilingDeleteVertexAffordance, ceilingMoveEdgeAffordance, ceilingMoveVertexAffordance, } from './floorplan-affordances';
@@ -100,6 +100,12 @@ export const ceilingDefinition = {
     schema: CeilingNode,
     category: 'structure',
     surfaceRole: 'ceiling',
+    extensions: {
+        [DRAFTING_SURFACE_EXTENSION_KEY]: {
+            kind: 'ceiling',
+            raycast: 'underside',
+        },
+    },
     // Height-less on purpose: a new ceiling follows the level top until the
     // user gives it an explicit custom height.
     defaults: () => ({
@@ -128,7 +134,7 @@ export const ceilingDefinition = {
         paint: ceilingPaint,
     },
     relations: {
-        hosts: ['item'],
+        hosts: ['item', 'procedural-item'],
         cascadeDelete: 'descendants',
     },
     parametrics: ceilingParametrics,

package/dist/ceiling/floorplan-affordances.d.ts

@@ -2,14 +2,14 @@ export declare const ceilingMoveVertexAffordance: import("@pascal-app/core").Flo
     object: "node";
     parentId: string | null;
     visible: boolean;
-    metadata: import("zod").JSONType;
+    metadata: Record<string, unknown>;
     id: `ceiling_${string}`;
     type: "ceiling";
-    children: `item_${string}`[];
+    children: (`item_${string}` | `procedural-item_${string}`)[];
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
-        source: "elevator" | "stair" | "manual";
+        source: "stair" | "elevator" | "manual";
         stairId?: string | undefined;
         elevatorId?: string | undefined;
     }[];
@@ -47,14 +47,14 @@ export declare const ceilingAddVertexAffordance: import("@pascal-app/core").Floo
     object: "node";
     parentId: string | null;
     visible: boolean;
-    metadata: import("zod").JSONType;
+    metadata: Record<string, unknown>;
     id: `ceiling_${string}`;
     type: "ceiling";
-    children: `item_${string}`[];
+    children: (`item_${string}` | `procedural-item_${string}`)[];
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
-        source: "elevator" | "stair" | "manual";
+        source: "stair" | "elevator" | "manual";
         stairId?: string | undefined;
         elevatorId?: string | undefined;
     }[];
@@ -92,14 +92,14 @@ export declare const ceilingMoveEdgeAffordance: import("@pascal-app/core").Floor
     object: "node";
     parentId: string | null;
     visible: boolean;
-    metadata: import("zod").JSONType;
+    metadata: Record<string, unknown>;
     id: `ceiling_${string}`;
     type: "ceiling";
-    children: `item_${string}`[];
+    children: (`item_${string}` | `procedural-item_${string}`)[];
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
-        source: "elevator" | "stair" | "manual";
+        source: "stair" | "elevator" | "manual";
         stairId?: string | undefined;
         elevatorId?: string | undefined;
     }[];
@@ -137,14 +137,14 @@ export declare const ceilingDeleteVertexAffordance: import("@pascal-app/core").F
     object: "node";
     parentId: string | null;
     visible: boolean;
-    metadata: import("zod").JSONType;
+    metadata: Record<string, unknown>;
     id: `ceiling_${string}`;
     type: "ceiling";
-    children: `item_${string}`[];
+    children: (`item_${string}` | `procedural-item_${string}`)[];
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
-        source: "elevator" | "stair" | "manual";
+        source: "stair" | "elevator" | "manual";
         stairId?: string | undefined;
         elevatorId?: string | undefined;
     }[];

package/dist/ceiling/materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"materials.d.ts","sourceRoot":"","sources":["../../src/ceiling/materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAuB,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAoBzE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,qBAAqB,CAAA;IAClC,cAAc,EAAE,qBAAqB,CAAA;CACtC,CAAA;AAsBD,wBAAgB,mBAAmB,CAAC,KAAK,SAAY,GAAG,gBAAgB,CAMvE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,cAAc,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,GACjE,MAAM,GAAG,IAAI,CASf"}
+{"version":3,"file":"materials.d.ts","sourceRoot":"","sources":["../../src/ceiling/materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAuB,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAoBzE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,qBAAqB,CAAA;IAClC,cAAc,EAAE,qBAAqB,CAAA;CACtC,CAAA;AAqBD,wBAAgB,mBAAmB,CAAC,KAAK,SAAY,GAAG,gBAAgB,CAMvE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,cAAc,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,GACjE,MAAM,GAAG,IAAI,CASf"}

package/dist/ceiling/materials.js

@@ -27,7 +27,6 @@ function createCeilingMaterials(color = '#999999') {
     topMaterial.opacityNode = gridOpacity;
     const bottomMaterial = new MeshBasicNodeMaterial({
         color,
-        transparent: true,
         side: BackSide,
     });
     return { topMaterial, bottomMaterial };

package/dist/ceiling/panel.js

@@ -185,7 +185,7 @@ export function CeilingPanel() {
     return (_jsxs(PanelWrapper, { icon: "/icons/ceiling.webp", onClose: handleClose, title: node.name || 'Ceiling', width: 320, children: [_jsxs(PanelSection, { title: "Height", children: [_jsx(SegmentedControl, { onChange: handleTopModeChange, options: [
                             { label: 'Follows level', value: 'storey' },
                             { label: 'Custom height', value: 'custom' },
-                        ], value: isFollows ? 'storey' : 'custom' }), isFollows ? (_jsxs("div", { className: "px-1 text-[11px] text-muted-foreground", children: ["Currently ", formatLinearMeasurement(resolvedHeight, unit, metricNotation)] })) : (_jsx(SliderControl, { label: "Height", max: Math.min(20, maxHeight), min: 0, onChange: handleHeightChange, precision: 3, step: 0.01, unit: "m", value: Math.round((node.height ?? resolvedHeight) * 1000) / 1000 })), _jsx("div", { className: "mt-2 grid grid-cols-3 gap-1.5 px-1 pb-1", children: heightPresets.map((preset) => {
+                        ], value: isFollows ? 'storey' : 'custom' }), isFollows ? (_jsxs("div", { className: "px-1 text-[11px] text-muted-foreground", children: ["Currently ", formatLinearMeasurement(resolvedHeight, unit, metricNotation)] })) : (_jsx(SliderControl, { label: "Height", max: Math.min(1000, maxHeight), min: 0, onChange: handleHeightChange, precision: 3, step: 0.01, unit: "m", value: node.height ?? resolvedHeight })), _jsx("div", { className: "mt-2 grid grid-cols-3 gap-1.5 px-1 pb-1", children: heightPresets.map((preset) => {
                             const fits = preset.height <= maxHeight;
                             return (_jsx(ActionButton, { className: fits ? undefined : 'cursor-not-allowed opacity-40', disabled: !fits, label: preset.label, onClick: () => handleHeightChange(preset.height), title: fits
                                     ? undefined

package/dist/ceiling/parametrics.js

@@ -9,7 +9,7 @@ export const ceilingParametrics = {
     groups: [
         {
             label: 'Dimensions',
-            fields: [{ key: 'height', kind: 'number', unit: 'm', min: 1.5, max: 20, step: 0.05 }],
+            fields: [{ key: 'height', kind: 'number', unit: 'm', min: 0.1, max: 1000, step: 0.05 }],
         },
     ],
     customPanel: () => import('./panel'),

package/dist/chimney/definition.js

@@ -378,7 +378,7 @@ export const chimneyDefinition = {
     presentation: {
         label: 'Chimney',
         description: 'Vertical masonry stack on a roof segment.',
-        icon: { kind: 'url', src: '/icons/roof.webp' },
+        icon: { kind: 'url', src: '/icons/chimney.webp' },
         paletteSection: 'structure',
         paletteOrder: 122,
     },