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

package/dist/pipe-trap/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/tool.tsx"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,QAAA,MAAM,YAAY,0CA4GjB,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/tool.tsx"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,QAAA,MAAM,YAAY,0CAqHjB,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/pipe-trap/tool.js

@@ -1,10 +1,12 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, PipeTrapNode, useScene } from '@pascal-app/core';
-import { isGridSnapActive, triggerSFX, useEditor } from '@pascal-app/editor';
+import { isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useEffect, useMemo, useRef, useState } from 'react';
+import { subscribeAccessorySnapping } from '../shared/accessory-snapping';
+import { alignDrawPoint, clearDrawAlignment } from '../shared/draw-alignment';
 import { LevelOffsetGroup } from '../shared/level-offset-group';
 import { pipeTrapDefinition } from './definition';
 import { buildPipeTrapGeometry } from './geometry';
@@ -50,11 +52,16 @@ const PipeTrapTool = () => {
         const resolve = (event) => {
             const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
             return {
-                position: [snap(event.localPosition[0], step), 0, snap(event.localPosition[2], step)],
+                position: alignDrawPoint([snap(event.localPosition[0], step), 0, snap(event.localPosition[2], step)], {
+                    applySnap: isMagneticSnapActive(),
+                    bypass: !isMagneticSnapActive(),
+                }),
                 diameter: diameterRef.current,
             };
         };
+        let lastEvent = null;
         const onMove = (event) => {
+            lastEvent = event;
             setCursor(resolve(event).position);
         };
         const onClick = (event) => {
@@ -83,13 +90,19 @@ const PipeTrapTool = () => {
                 triggerSFX('sfx:item-rotate');
             }
         };
+        const unsubscribeSnapping = subscribeAccessorySnapping(() => {
+            if (lastEvent)
+                onMove(lastEvent);
+        });
         emitter.on('grid:move', onMove);
         emitter.on('grid:click', onClick);
         window.addEventListener('keydown', onKeyDown, true);
         return () => {
+            unsubscribeSnapping();
             emitter.off('grid:move', onMove);
             emitter.off('grid:click', onClick);
             window.removeEventListener('keydown', onKeyDown, true);
+            clearDrawAlignment();
         };
     }, [activeLevelId]);
     if (!activeLevelId || !cursor)

package/dist/ridge-vent/definition.js

@@ -185,7 +185,7 @@ export const ridgeVentDefinition = {
     presentation: {
         label: 'Ridge Vent',
         description: 'Ventilation strip running along the ridge of a roof segment.',
-        icon: { kind: 'url', src: '/icons/roof.webp' },
+        icon: { kind: 'url', src: '/icons/ridge-vent.webp' },
         paletteSection: 'structure',
         paletteOrder: 121,
     },

package/dist/ridge-vent/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/panel.tsx"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,uCAmQrC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/panel.tsx"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,uCAiQrC"}

package/dist/ridge-vent/panel.js

@@ -102,11 +102,11 @@ export default function RidgeVentPanel() {
                         ], value: node.style ?? 'standard' }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ endCaps: v === 'yes' }), options: [
                             { label: 'End Caps', value: 'yes' },
                             { label: 'Open', value: 'no' },
-                        ], value: (node.endCaps ?? true) ? 'yes' : 'no' })] }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Length", max: 8, min: 0.5, onChange: (v) => handleUpdate({ length: v }), onCommit: (v) => handleUpdate({ length: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.length * 100) / 100 }), _jsx(SliderControl, { label: "Width", max: 0.6, min: 0.1, onChange: (v) => handleUpdate({ width: v }), onCommit: (v) => handleUpdate({ width: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(node.width * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: 0.2, min: 0.03, onChange: (v) => handleUpdate({ height: v }), onCommit: (v) => handleUpdate({ height: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round(node.height * 1000) / 1000 })] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: halfW, min: -halfW, onChange: (v) => handleUpdate({
+                        ], value: (node.endCaps ?? true) ? 'yes' : 'no' })] }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Length", max: 1000, min: 0.5, onChange: (v) => handleUpdate({ length: v }), onCommit: (v) => handleUpdate({ length: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.length * 100) / 100 }), _jsx(SliderControl, { label: "Width", max: 0.6, min: 0.1, onChange: (v) => handleUpdate({ width: v }), onCommit: (v) => handleUpdate({ width: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(node.width * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: 0.2, min: 0.03, onChange: (v) => handleUpdate({ height: v }), onCommit: (v) => handleUpdate({ height: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round(node.height * 1000) / 1000 })] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: halfW, min: -halfW, onChange: (v) => handleUpdate({
                             position: [v, node.position[1] ?? 0, node.position[2] ?? 0],
                         }), onCommit: (v) => handleUpdate({
                             position: [v, node.position[1] ?? 0, node.position[2] ?? 0],
-                        }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[0] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Y", max: 2, min: -2, onChange: (v) => handleUpdate({
+                        }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[0] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Y", onChange: (v) => handleUpdate({
                             position: [node.position[0] ?? 0, v, node.position[2] ?? 0],
                         }), onCommit: (v) => handleUpdate({
                             position: [node.position[0] ?? 0, v, node.position[2] ?? 0],

package/dist/ridge-vent/parametrics.js

@@ -19,7 +19,7 @@ export const ridgeVentParametrics = {
         {
             label: 'Dimensions',
             fields: [
-                { key: 'length', kind: 'number', unit: 'm', min: 0.5, max: 8, step: 0.05 },
+                { key: 'length', kind: 'number', unit: 'm', min: 0.5, max: 1000, step: 0.05 },
                 { key: 'width', kind: 'number', unit: 'm', min: 0.1, max: 0.6, step: 0.01 },
                 { key: 'height', kind: 'number', unit: 'm', min: 0.03, max: 0.2, step: 0.005 },
             ],

package/dist/ridge-vent/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,aAAa,EAMnB,MAAM,kBAAkB,CAAA;AAuDzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,iBAAiB,GAAI,qBAAqB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,uCAiMtE,CAAA;AAED,eAAe,iBAAiB,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,aAAa,EAMnB,MAAM,kBAAkB,CAAA;AAuDzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,iBAAiB,GAAI,qBAAqB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,uCAiMtE,CAAA;AAED,eAAe,iBAAiB,CAAA"}

package/dist/ridge-vent/renderer.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { getEffectiveRoofSurfaceMaterial, getEffectiveSegmentSurfaceMaterial, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { getEffectiveRoofSurfaceMaterial, getEffectiveSegmentSurfaceMaterial, normalizeRoofSegmentTrim, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
 import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, getRoofMaterialArray, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
@@ -11,7 +11,7 @@ import { buildRidgeVentGeometry } from './geometry';
 function ridgeVentSegmentGeometryKey(segment) {
     if (!segment)
         return 'none';
-    const trim = segment.trim;
+    const trim = normalizeRoofSegmentTrim(segment);
     return [
         segment.roofType,
         segment.width,

package/dist/roof/conical-roof-placement.d.ts

@@ -0,0 +1,36 @@
+import { type AnyNode, type LevelNode, type RoofNode, type RoofSupport } from '@pascal-app/core';
+export type ConicalRoofLevelPlacement = {
+    valid: true;
+    kind: 'level';
+    position: [number, number, number];
+    wallHeight: number;
+    support: Extract<RoofSupport, {
+        kind: 'level';
+    }>;
+};
+export type ConicalRoofSurfacePlacement = {
+    valid: true;
+    kind: 'roof';
+    position: [number, number, number];
+    wallHeight: number;
+    hostRoofId: RoofNode['id'];
+    support: Extract<RoofSupport, {
+        kind: 'roof';
+    }>;
+};
+export type ConicalRoofInvalidPlacement = {
+    valid: false;
+    reason: 'no-roof-support';
+};
+export type ConicalRoofPlacement = ConicalRoofLevelPlacement | ConicalRoofSurfacePlacement | ConicalRoofInvalidPlacement;
+export type ResolveConicalRoofPlacementInput = {
+    nodes: Readonly<Record<string, AnyNode>>;
+    levelId: LevelNode['id'];
+    center: readonly [number, number];
+    radius: number;
+    curbHeight: number;
+    allowRoofSupport: boolean;
+    requireRoofSupport: boolean;
+};
+export declare function resolveConicalRoofPlacement({ nodes, levelId, center, radius, curbHeight, allowRoofSupport, requireRoofSupport, }: ResolveConicalRoofPlacementInput): ConicalRoofPlacement;
+//# sourceMappingURL=conical-roof-placement.d.ts.map

package/dist/roof/conical-roof-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conical-roof-placement.d.ts","sourceRoot":"","sources":["../../src/roof/conical-roof-placement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,SAAS,EACd,KAAK,QAAQ,EAEb,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAA;AAEzB,MAAM,MAAM,yBAAyB,GAAG;IACtC,KAAK,EAAE,IAAI,CAAA;IACX,IAAI,EAAE,OAAO,CAAA;IACb,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,OAAO,CAAC,WAAW,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;CACjD,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,KAAK,EAAE,IAAI,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC1B,OAAO,EAAE,OAAO,CAAC,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChD,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,KAAK,EAAE,KAAK,CAAA;IACZ,MAAM,EAAE,iBAAiB,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,oBAAoB,GAC5B,yBAAyB,GACzB,2BAA2B,GAC3B,2BAA2B,CAAA;AAE/B,MAAM,MAAM,gCAAgC,GAAG;IAC7C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACxC,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACxB,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB,EAAE,OAAO,CAAA;IACzB,kBAAkB,EAAE,OAAO,CAAA;CAC5B,CAAA;AAsJD,wBAAgB,2BAA2B,CAAC,EAC1C,KAAK,EACL,OAAO,EACP,MAAM,EACN,MAAM,EACN,UAAU,EACV,gBAAgB,EAChB,kBAAkB,GACnB,EAAE,gCAAgC,GAAG,oBAAoB,CAyBzD"}

package/dist/roof/conical-roof-placement.js

@@ -0,0 +1,134 @@
+import { getRoofSegmentSurfaceY, } from '@pascal-app/core';
+const CUTTER_SEAT_DEPTH = 0.1;
+const FOOTPRINT_EPSILON = 1e-6;
+const CIRCLE_SEGMENTS = 32;
+const HEIGHT_GRID_STEPS = 8;
+function inverseRotatePlan(x, z, rotation) {
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    return [x * cos - z * sin, x * sin + z * cos];
+}
+function worldToSegmentPlan(roof, segment, point) {
+    const [roofX, roofZ] = inverseRotatePlan(point[0] - roof.position[0], point[1] - roof.position[2], roof.rotation ?? 0);
+    return inverseRotatePlan(roofX - segment.position[0], roofZ - segment.position[2], segment.rotation ?? 0);
+}
+function pointIsInsideSegment(segment, point) {
+    if (segment.roofType === 'conical') {
+        if (Math.hypot(point[0], point[1]) > segment.width / 2 + FOOTPRINT_EPSILON)
+            return false;
+        if (segment.conicalFullCircle)
+            return true;
+        const start = segment.conicalStartAngle ?? 0;
+        const sweep = segment.conicalSweepAngle ?? Math.PI * 2;
+        if (Math.abs(sweep) >= Math.PI * 2 - FOOTPRINT_EPSILON)
+            return true;
+        const angle = Math.atan2(point[1], point[0]);
+        const directedDelta = (from, to) => {
+            const delta = (to - from) % (Math.PI * 2);
+            return delta < 0 ? delta + Math.PI * 2 : delta;
+        };
+        return sweep >= 0
+            ? directedDelta(start, angle) <= sweep + FOOTPRINT_EPSILON
+            : directedDelta(angle, start) <= -sweep + FOOTPRINT_EPSILON;
+    }
+    return (Math.abs(point[0]) <= segment.width / 2 + FOOTPRINT_EPSILON &&
+        Math.abs(point[1]) <= segment.depth / 2 + FOOTPRINT_EPSILON);
+}
+function circleBoundary(center, radius) {
+    if (radius <= FOOTPRINT_EPSILON)
+        return [[center[0], center[1]]];
+    return Array.from({ length: CIRCLE_SEGMENTS }, (_, index) => {
+        const angle = (index / CIRCLE_SEGMENTS) * Math.PI * 2;
+        return [center[0] + Math.cos(angle) * radius, center[1] + Math.sin(angle) * radius];
+    });
+}
+function circleHeightSamples(center, radius) {
+    const samples = circleBoundary(center, radius);
+    if (radius <= FOOTPRINT_EPSILON)
+        return samples;
+    for (let zIndex = 0; zIndex <= HEIGHT_GRID_STEPS; zIndex += 1) {
+        const z = -radius + (zIndex / HEIGHT_GRID_STEPS) * radius * 2;
+        for (let xIndex = 0; xIndex <= HEIGHT_GRID_STEPS; xIndex += 1) {
+            const x = -radius + (xIndex / HEIGHT_GRID_STEPS) * radius * 2;
+            if (x * x + z * z > radius * radius + FOOTPRINT_EPSILON)
+                continue;
+            samples.push([center[0] + x, center[1] + z]);
+        }
+    }
+    return samples;
+}
+function findRoofCandidate(nodes, levelId, center, radius) {
+    const boundary = circleBoundary(center, radius);
+    const heightSamples = circleHeightSamples(center, radius);
+    let best = null;
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'roof' || node.parentId !== levelId)
+            continue;
+        const roof = node;
+        for (const segmentId of roof.children ?? []) {
+            const child = nodes[segmentId];
+            if (child?.type !== 'roof-segment')
+                continue;
+            const segment = child;
+            if (!boundary.every((point) => pointIsInsideSegment(segment, worldToSegmentPlan(roof, segment, point)))) {
+                continue;
+            }
+            let minSurfaceY = Number.POSITIVE_INFINITY;
+            let maxSurfaceY = Number.NEGATIVE_INFINITY;
+            for (const point of heightSamples) {
+                const local = worldToSegmentPlan(roof, segment, point);
+                const surfaceY = roof.position[1] +
+                    segment.position[1] +
+                    getRoofSegmentSurfaceY(segment, local[0], local[1]);
+                minSurfaceY = Math.min(minSurfaceY, surfaceY);
+                maxSurfaceY = Math.max(maxSurfaceY, surfaceY);
+            }
+            if (!(Number.isFinite(minSurfaceY) && Number.isFinite(maxSurfaceY)))
+                continue;
+            if (best && best.maxSurfaceY >= maxSurfaceY)
+                continue;
+            best = {
+                roof,
+                segment,
+                localCenter: worldToSegmentPlan(roof, segment, center),
+                minSurfaceY,
+                maxSurfaceY,
+            };
+        }
+    }
+    return best;
+}
+function levelPlacement(center, curbHeight) {
+    return {
+        valid: true,
+        kind: 'level',
+        position: [center[0], 0, center[1]],
+        wallHeight: Math.max(0, curbHeight),
+        support: { kind: 'level' },
+    };
+}
+export function resolveConicalRoofPlacement({ nodes, levelId, center, radius, curbHeight, allowRoofSupport, requireRoofSupport, }) {
+    if (!allowRoofSupport)
+        return levelPlacement(center, curbHeight);
+    const candidate = findRoofCandidate(nodes, levelId, center, Math.max(0, radius));
+    if (!candidate) {
+        return requireRoofSupport
+            ? { valid: false, reason: 'no-roof-support' }
+            : levelPlacement(center, curbHeight);
+    }
+    const safeCurbHeight = Math.max(0, curbHeight);
+    const baseY = candidate.minSurfaceY - CUTTER_SEAT_DEPTH;
+    return {
+        valid: true,
+        kind: 'roof',
+        position: [center[0], baseY, center[1]],
+        wallHeight: candidate.maxSurfaceY - baseY + safeCurbHeight,
+        hostRoofId: candidate.roof.id,
+        support: {
+            kind: 'roof',
+            roofSegmentId: candidate.segment.id,
+            localPosition: candidate.localCenter,
+            curbHeight: safeCurbHeight,
+        },
+    };
+}

package/dist/roof/conical-roof.d.ts

@@ -0,0 +1,3 @@
+import { type AnyNode, type AnyNodeId, type LevelNode, RoofSegmentNode, type SceneApi, type WallNode } from '@pascal-app/core';
+export declare function createConicalRoofSectorAboveWall(wall: WallNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>, sceneApi: SceneApi, targetLevelId: LevelNode['id']): RoofSegmentNode['id'] | null;
+//# sourceMappingURL=conical-roof.d.ts.map

package/dist/roof/conical-roof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conical-roof.d.ts","sourceRoot":"","sources":["../../src/roof/conical-roof.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAGd,KAAK,SAAS,EAEd,eAAe,EAGf,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAIzB,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAC3C,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,GAC7B,eAAe,CAAC,IAAI,CAAC,GAAG,IAAI,CAkD9B"}

package/dist/roof/conical-roof.js

@@ -0,0 +1,53 @@
+import { getLevelBelow, getWallArcData, RoofNode, RoofSegmentNode, resolveLevelId, resolveRoofWallTopElevation, } from '@pascal-app/core';
+const DEFAULT_CONICAL_ROOF_PITCH = 40;
+export function createConicalRoofSectorAboveWall(wall, nodes, sceneApi, targetLevelId) {
+    const arc = getWallArcData(wall);
+    if (!(arc && nodes[targetLevelId]?.type === 'level'))
+        return null;
+    const completeNodes = nodes;
+    const sourceLevelId = resolveLevelId(wall, completeNodes);
+    const levelBelowId = getLevelBelow(targetLevelId, completeNodes)?.id;
+    if (sourceLevelId !== targetLevelId && sourceLevelId !== levelBelowId)
+        return null;
+    const existingRoof = Object.values(nodes).find((node) => node.type === 'roof' &&
+        node.parentId === targetLevelId &&
+        typeof node.metadata === 'object' &&
+        node.metadata !== null &&
+        !Array.isArray(node.metadata) &&
+        node.metadata.conicalSourceWallId === wall.id);
+    if (existingRoof) {
+        const existingSegment = existingRoof.children
+            .map((childId) => nodes[childId])
+            .find((node) => node?.type === 'roof-segment');
+        if (existingSegment)
+            return existingSegment.id;
+    }
+    const roofCount = Object.values(nodes).filter((node) => node?.type === 'roof').length;
+    const segment = RoofSegmentNode.parse({
+        roofType: 'conical',
+        width: arc.radius * 2,
+        depth: arc.radius * 2,
+        wallHeight: 0,
+        pitch: DEFAULT_CONICAL_ROOF_PITCH,
+        conicalStartAngle: arc.startAngle,
+        conicalSweepAngle: arc.delta,
+        conicalFullCircle: true,
+    });
+    const roof = RoofNode.parse({
+        name: `Roof ${roofCount + 1}`,
+        metadata: { conicalSourceWallId: wall.id },
+        support: { kind: 'walls' },
+        position: [arc.center.x, resolveRoofWallTopElevation(targetLevelId, wall, nodes), arc.center.y],
+        children: [segment.id],
+    });
+    const ops = [
+        { node: roof, parentId: targetLevelId },
+        { node: segment, parentId: roof.id },
+    ];
+    if (sceneApi.createMany)
+        sceneApi.createMany(ops);
+    else
+        for (const op of ops)
+            sceneApi.upsert(op.node, op.parentId);
+    return segment.id;
+}

package/dist/roof/definition.d.ts

@@ -1,16 +1,9 @@
 import { type NodeDefinition } from '@pascal-app/core';
 import { RoofNode } from './schema';
 /**
- * Roof — Stage A registration. Wrap-exports the legacy `RoofRenderer`
- * + `RoofSystem` (geometry generation via `getRoofSegmentBrushes` +
- * CSG). Inspector / move stay legacy until Stage B-E. `floorplan` draws
- * the merged silhouette (union of the child segments' footprints), so a
- * multi-segment roof reads as one combined shape rather than stacked
- * rectangles.
- *
- * Roof is a "composite" node — it has `roof-segment` children that
- * own per-segment geometry. The parent roof handles overall framing;
- * each segment is its own registered kind (see `roof-segment`).
+ * Roof is a composite node with `roof-segment` children that own the
+ * per-segment geometry. Its floor-plan contribution merges those child
+ * footprints so a multi-segment roof reads as one shape.
  */
 export declare const roofDefinition: NodeDefinition<typeof RoofNode>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsEnC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAoG1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsFnC;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAgK1D,CAAA"}

package/dist/roof/definition.js

@@ -1,6 +1,9 @@
 import { RoofNode as RoofNodeSchema, } from '@pascal-app/core';
+import { DRAFTING_SURFACE_EXTENSION_KEY } from '@pascal-app/editor';
 import { buildRoofFloorplan } from './floorplan';
 import { roofParametrics } from './parametrics';
+import useRoofFootprintSource from './roof-footprint-source';
+import useRoofPlacementMode, { conicalRoofToolHintVisibility, standardRoofToolHintVisibility, } from './roof-placement-mode';
 import { RoofNode } from './schema';
 const MOVE_FRONT_OFFSET = 0.35;
 const MIN_ROOF_FOOTPRINT = 1;
@@ -45,7 +48,12 @@ function roofMoveHandle() {
                 return [(bounds.minX + bounds.maxX) / 2, 0.02, bounds.maxZ + MOVE_FRONT_OFFSET];
             },
         },
-        apply: (_node, position) => ({ position: [position[0], position[1], position[2]] }),
+        apply: (node, position) => ({
+            position: [position[0], position[1], position[2]],
+            ...(node.support?.kind === 'walls' && Math.abs(position[1] - node.position[1]) > 1e-4
+                ? { support: { kind: 'level' } }
+                : {}),
+        }),
         snapExtents: (node, sceneApi) => {
             const bounds = getRoofFootprintBounds(node, sceneApi);
             const width = Math.max(bounds.maxX - bounds.minX, MIN_ROOF_FOOTPRINT);
@@ -56,17 +64,20 @@ function roofMoveHandle() {
     };
 }
 const roofHandles = [roofMoveHandle()];
+function isManagedLeanToRoof(node) {
+    const metadata = node.metadata;
+    if (!(metadata && typeof metadata === 'object' && !Array.isArray(metadata)))
+        return false;
+    const record = metadata;
+    return record.managedByLeanTo !== undefined && record.leanToRole === 'roof';
+}
+function resolveRoofHandles(node) {
+    return isManagedLeanToRoof(node) ? [] : roofHandles;
+}
 /**
- * Roof — Stage A registration. Wrap-exports the legacy `RoofRenderer`
- * + `RoofSystem` (geometry generation via `getRoofSegmentBrushes` +
- * CSG). Inspector / move stay legacy until Stage B-E. `floorplan` draws
- * the merged silhouette (union of the child segments' footprints), so a
- * multi-segment roof reads as one combined shape rather than stacked
- * rectangles.
- *
- * Roof is a "composite" node — it has `roof-segment` children that
- * own per-segment geometry. The parent roof handles overall framing;
- * each segment is its own registered kind (see `roof-segment`).
+ * Roof is a composite node with `roof-segment` children that own the
+ * per-segment geometry. Its floor-plan contribution merges those child
+ * footprints so a multi-segment roof reads as one shape.
  */
 export const roofDefinition = {
     kind: 'roof',
@@ -74,10 +85,15 @@ export const roofDefinition = {
     // Drafted as a 2-corner footprint (axis-aligned bbox), not a directional
     // edge → no angle-lock mode (grid / lines / off only).
     snapDraftDirectional: false,
-    schemaVersion: 1,
+    schemaVersion: 3,
     schema: RoofNode,
     category: 'structure',
     surfaceRole: 'roof',
+    extensions: {
+        [DRAFTING_SURFACE_EXTENSION_KEY]: {
+            kind: 'roof',
+        },
+    },
     defaults: () => {
         const stub = RoofNodeSchema.parse({ id: 'roof_default', type: 'roof' });
         const { id: _id, type: _type, ...rest } = stub;
@@ -146,8 +162,62 @@ export const roofDefinition = {
     affordanceTools: {
         move: () => import('../shared/move-roof-tool'),
     },
+    tool: () => import('./tool'),
+    toolHints: [
+        { key: 'Left click', label: 'Set roof footprint' },
+        {
+            key: 'P',
+            label: 'Placement',
+            visible: conicalRoofToolHintVisibility,
+            chip: {
+                subscribe: (onChange) => useRoofPlacementMode.subscribe(onChange),
+                value: () => useRoofPlacementMode.getState().mode,
+                cycle: () => useRoofPlacementMode.getState().cycleMode(),
+                labels: {
+                    auto: 'Placement: Auto',
+                    ground: 'Placement: Ground',
+                    roof: 'Placement: Roof',
+                },
+                icons: {
+                    auto: 'lucide:scan-search',
+                    ground: 'lucide:land-plot',
+                    roof: 'lucide:house',
+                },
+                tooltip: 'Placement surface - click or press P to cycle',
+            },
+        },
+        {
+            key: 'R',
+            label: 'Rotate roof direction 90°',
+            visible: standardRoofToolHintVisibility,
+        },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    toolOptions: [
+        {
+            id: 'footprintSource',
+            label: 'Create from',
+            choices: [
+                {
+                    value: 'draw',
+                    label: 'Draw',
+                    description: 'Draw the roof footprint with two corner clicks.',
+                },
+                {
+                    value: 'room',
+                    label: 'Room',
+                    description: 'Hover a room to preview its boundary, then click to place.',
+                },
+            ],
+            subscribe: (onChange) => useRoofFootprintSource.subscribe(onChange),
+            value: () => useRoofFootprintSource.getState().source,
+            set: (value) => useRoofFootprintSource.getState().setSource(value === 'room' ? 'room' : 'draw'),
+            // Conical roofs always build from a curved wall pick; the row would lie.
+            visible: standardRoofToolHintVisibility,
+        },
+    ],
     parametrics: roofParametrics,
-    handles: roofHandles,
+    handles: resolveRoofHandles,
     floorplan: buildRoofFloorplan,
     renderer: {
         kind: 'parametric',

package/dist/roof/floorplan.d.ts

@@ -1,15 +1,8 @@
-import type { FloorplanGeometry, GeometryContext, RoofNode } from '@pascal-app/core';
+import { type FloorplanGeometry, type GeometryContext, type RoofNode } from '@pascal-app/core';
 /**
  * Roof-level floor-plan builder. Draws the whole merged-roof plan: the
- * unioned silhouette, the valley diagonals at concave junctions, and every
- * segment's ridge/hip/break linework — clipped so a line stops at the valley
- * where its segment overlaps a neighbour, instead of running on at the
- * segment's full length into the cut-away part.
- *
- * Drawing all the linework here (rather than per-segment) is what lets the
- * clip work: the valleys and the neighbouring footprints are all in hand, so
- * each line can be trimmed to the actual merged geometry. The segment
- * builder keeps only its hit-target / selection chrome.
+ * unioned silhouette and every segment's ridge/hip/break linework. The
+ * segment builder keeps only its hit-target / selection chrome.
  *
  * Composition uses the floor plan's negated-rotation convention
  * (segment-local → roof-local → plan). `unionPolygons` returns one ring per

package/dist/roof/floorplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAEjB,eAAe,EACf,QAAQ,EAET,MAAM,kBAAkB,CAAA;AAqHzB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAuJjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EACpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAuIzB;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAwHjG"}