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

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAkP1C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA4ExE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAoS1C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA4ExE,CAAA"}

package/dist/roof-segment/definition.js

@@ -6,6 +6,7 @@ import { roofSegmentParametrics } from './parametrics';
 import { RoofSegmentNode } from './schema';
 const SIDE_HANDLE_OFFSET = 0.3;
 const HEIGHT_HANDLE_OFFSET = 0.3;
+const ROOF_HANDLE_CLEARANCE = 0.15;
 const ROTATE_CORNER_OFFSET = 0.4;
 const ROTATE_RING_OFFSET = 0.08;
 const MIN_ROOF_DIM = 1;
@@ -22,6 +23,15 @@ const MAX_PITCH = 85;
 function getPeakHeight(n) {
     return n.wallHeight + getActiveRoofHeight(n);
 }
+function getSideResizeHandleY(n, localZ) {
+    if (n.roofType !== 'shed')
+        return Math.max(n.wallHeight, MIN_WALL_DISPLAY) / 2;
+    const halfDepth = Math.max(n.depth, MIN_ROOF_DIM) / 2;
+    const roofHeight = getActiveRoofHeight(n);
+    const t = halfDepth > 0 ? (localZ + halfDepth) / (2 * halfDepth) : 0.5;
+    const roofY = n.wallHeight + roofHeight * (1 - Math.max(0, Math.min(1, t)));
+    return Math.max(roofY, MIN_WALL_DISPLAY) + ROOF_HANDLE_CLEARANCE;
+}
 // Width arrow on the +X (right) or -X (left) side. Asymmetric resize:
 // dragging one arrow grows the segment outward from its own edge while
 // the opposite edge stays world-fixed — the same pattern doors use
@@ -55,15 +65,12 @@ function roofSegmentWidthHandle(side) {
             const newCenterZ = anchorZ + sign * (newWidth / 2) * armZ;
             return {
                 width: newWidth,
+                ...(initial.roofType === 'conical' ? { depth: newWidth } : {}),
                 position: [newCenterX, initial.position[1], newCenterZ],
             };
         },
         placement: {
-            position: (n) => [
-                sign * (n.width / 2 + SIDE_HANDLE_OFFSET),
-                Math.max(n.wallHeight, MIN_WALL_DISPLAY) / 2,
-                0,
-            ],
+            position: (n) => [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), getSideResizeHandleY(n, 0), 0],
             // Flip the left chevron so it points outward toward -X. The
             // generic LinearArrow only auto-orients for axis 'z' (rotates the
             // chevron 90° to face +Z); +X / -X facing is up to the descriptor.
@@ -100,6 +107,13 @@ function roofSegmentDepthHandle(side) {
             const anchorZ = initial.position[2] - sign * (initial.depth / 2) * armZ;
             const newCenterX = anchorX + sign * (newDepth / 2) * armX;
             const newCenterZ = anchorZ + sign * (newDepth / 2) * armZ;
+            if (initial.roofType === 'conical') {
+                return {
+                    width: newDepth,
+                    depth: newDepth,
+                    position: [newCenterX, initial.position[1], newCenterZ],
+                };
+            }
             // Preserve peak height — back-solve pitch for the new depth so
             // the assembled roof height matches what it was before the drag.
             const originalRoofHeight = getActiveRoofHeight(initial);
@@ -124,7 +138,7 @@ function roofSegmentDepthHandle(side) {
         placement: {
             position: (n) => [
                 0,
-                Math.max(n.wallHeight, MIN_WALL_DISPLAY) / 2,
+                getSideResizeHandleY(n, sign * (n.depth / 2)),
                 sign * (n.depth / 2 + SIDE_HANDLE_OFFSET),
             ],
             // For axis 'z', `LinearArrow` adds -π/2 around Y so the chevron
@@ -133,6 +147,23 @@ function roofSegmentDepthHandle(side) {
         },
     };
 }
+function conicalRoofSegmentRadiusHandle() {
+    return {
+        kind: 'radial-resize',
+        axis: 'x',
+        min: MIN_ROOF_DIM / 2,
+        currentValue: (n) => n.width / 2,
+        apply: (_initial, radius) => ({ width: radius * 2, depth: radius * 2 }),
+        placement: {
+            position: (n) => [n.width / 2 + SIDE_HANDLE_OFFSET, getSideResizeHandleY(n, 0), 0],
+        },
+        decoration: {
+            kind: 'ring',
+            radius: (n) => n.width / 2,
+            y: (n) => getSideResizeHandleY(n, 0),
+        },
+    };
+}
 // Wall-height tracker — dashed vertical leader from the floor up to a
 // draggable cube at the wall top, centred on the footprint. Replaces
 // the old -X-side chevron so the wall-top control reads as "the wall is
@@ -149,6 +180,7 @@ function roofSegmentWallHeightHandle() {
         anchor: 'min',
         shape: 'tracker',
         min: MIN_WALL_HEIGHT,
+        gridSnap: true,
         currentValue: (n) => n.wallHeight,
         apply: (_n, newValue) => ({ wallHeight: newValue }),
         placement: {
@@ -174,7 +206,9 @@ function roofSegmentPitchHandle() {
         axis: 'y',
         anchor: 'min',
         min: (n) => n.wallHeight,
+        gridSnap: true,
         currentValue: (n) => getPeakHeight(n),
+        visible: (n) => !n.managedByParent,
         apply: (initial, newPeakHeight) => {
             const roofHeight = Math.max(0, newPeakHeight - initial.wallHeight);
             const pitch = getPitchFromActiveRoofHeight({
@@ -234,6 +268,16 @@ const roofSegmentHandles = [
     roofSegmentPitchHandle(),
     roofSegmentRotateHandle(),
 ];
+const conicalRoofSegmentHandles = [
+    conicalRoofSegmentRadiusHandle(),
+    roofSegmentWallHeightHandle(),
+    roofSegmentPitchHandle(),
+];
+function resolveRoofSegmentHandles(node) {
+    if (node.managedByParent)
+        return [];
+    return node.roofType === 'conical' ? conicalRoofSegmentHandles : roofSegmentHandles;
+}
 /**
  * Roof segment — Stage A. Child of a roof node, owns the per-segment
  * polygon + pitch. Geometry is generated by `RoofSystem` (registered
@@ -242,7 +286,7 @@ const roofSegmentHandles = [
  */
 export const roofSegmentDefinition = {
     kind: 'roof-segment',
-    schemaVersion: 1,
+    schemaVersion: 5,
     schema: RoofSegmentNode,
     category: 'structure',
     surfaceRole: 'roof',
@@ -271,7 +315,7 @@ export const roofSegmentDefinition = {
         move: () => import('../shared/move-roof-tool'),
     },
     parametrics: roofSegmentParametrics,
-    handles: roofSegmentHandles,
+    handles: resolveRoofSegmentHandles,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/roof-segment/floorplan-affordances.d.ts

@@ -1,12 +1,11 @@
 import { type FloorplanAffordance, type FloorplanMoveTarget, type RoofSegmentNode } from '@pascal-app/core';
 /**
  * Roof-segment width / depth drag (floor-plan). Mirrors the 3D
- * `linear-resize` handles in `definition.ts` — `anchor: 'center'`
- * means dragging outward on either +/-X (or +/-Z) edge grows the
- * dimension by 2× the segment-local cursor offset while the segment's
- * roof-local position stays put. Projects the plan cursor onto the
- * segment's effective rotation (roof.rotation + segment.rotation) so
- * the math survives any parent-roof rotation.
+ * `linear-resize` handles in `definition.ts`: the dragged side moves
+ * while the opposite side stays fixed. Projects the plan cursor onto
+ * the segment's effective rotation (roof.rotation + segment.rotation)
+ * so the math survives any parent-roof rotation, then writes the
+ * corresponding roof-local center shift alongside the new dimension.
  */
 export declare const roofSegmentResizeAffordance: FloorplanAffordance<RoofSegmentNode>;
 /**

package/dist/roof-segment/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/roof-segment/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EAExB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AA4CzB;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CAgD5E,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CA8B5E,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,eAAe,CA2CtE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/roof-segment/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EAExB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AA4CzB;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CAsG5E,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CA8B5E,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,eAAe,CA2CtE,CAAA"}

package/dist/roof-segment/floorplan-affordances.js

@@ -1,5 +1,5 @@
 import { snapScalar, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { getSegmentGridStep, isAngleSnapActive } from '@pascal-app/editor';
+import { getSegmentGridStep, isAngleSnapActive, isGridSnapActive } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
 import { rotateAffordanceDelta } from '../shared/rotate-affordance';
 const MIN_ROOF_DIM = 1;
@@ -29,19 +29,47 @@ function resolveSegmentFrame(segment, nodes) {
 }
 /**
  * Roof-segment width / depth drag (floor-plan). Mirrors the 3D
- * `linear-resize` handles in `definition.ts` — `anchor: 'center'`
- * means dragging outward on either +/-X (or +/-Z) edge grows the
- * dimension by 2× the segment-local cursor offset while the segment's
- * roof-local position stays put. Projects the plan cursor onto the
- * segment's effective rotation (roof.rotation + segment.rotation) so
- * the math survives any parent-roof rotation.
+ * `linear-resize` handles in `definition.ts`: the dragged side moves
+ * while the opposite side stays fixed. Projects the plan cursor onto
+ * the segment's effective rotation (roof.rotation + segment.rotation)
+ * so the math survives any parent-roof rotation, then writes the
+ * corresponding roof-local center shift alongside the new dimension.
  */
 export const roofSegmentResizeAffordance = {
     start({ node, payload, nodes, initialPlanPoint }) {
-        const { axis, side } = payload;
+        const resize = payload;
         const segmentId = node.id;
+        const { cx, cz } = resolveSegmentFrame(node, nodes);
+        if ('mode' in resize) {
+            const initialRadius = node.width / 2;
+            const initialPointerRadius = Math.hypot(initialPlanPoint[0] - cx, initialPlanPoint[1] - cz);
+            let lastRadius = initialRadius;
+            return {
+                affectedIds: [segmentId],
+                apply({ planPoint }) {
+                    const pointerRadius = Math.hypot(planPoint[0] - cx, planPoint[1] - cz);
+                    lastRadius = Math.max(MIN_ROOF_DIM / 2, initialRadius + pointerRadius - initialPointerRadius);
+                    const diameter = lastRadius * 2;
+                    useLiveNodeOverrides.getState().set(segmentId, { width: diameter, depth: diameter });
+                    useScene.getState().markDirty(segmentId);
+                },
+                canCommit() {
+                    return true;
+                },
+                commit() {
+                    useLiveNodeOverrides.getState().clear(segmentId);
+                    const diameter = lastRadius * 2;
+                    useScene.getState().updateNode(segmentId, { width: diameter, depth: diameter });
+                },
+            };
+        }
+        const { axis, side } = resize;
         const initialValue = axis === 'x' ? node.width : node.depth;
-        const { cx, cz, effRot } = resolveSegmentFrame(node, nodes);
+        const initialPosition = node.position;
+        const segmentRotation = node.rotation ?? 0;
+        const armX = axis === 'x' ? Math.cos(segmentRotation) : Math.sin(segmentRotation);
+        const armZ = axis === 'x' ? -Math.sin(segmentRotation) : Math.cos(segmentRotation);
+        const { effRot } = resolveSegmentFrame(node, nodes);
         const cosEff = Math.cos(effRot);
         const sinEff = Math.sin(effRot);
         // Project (planPoint - center) onto the segment's local X or Z axis
@@ -59,17 +87,26 @@ export const roofSegmentResizeAffordance = {
             apply({ planPoint }) {
                 const currentLocal = projectLocalAxis(planPoint[0], planPoint[1]);
                 const delta = (currentLocal - initialLocal) * side;
-                const rawValue = initialValue + 2 * delta;
+                const rawValue = initialValue + delta;
                 // Mode-aware grid step (0 outside grid mode, so `lines` / `off` resize
                 // freely — the "smooth" behaviour that used to need a held Shift). The
                 // reshaping scope opened by the dispatcher resolves the `polygon` set.
-                const step = getSegmentGridStep();
+                const step = isGridSnapActive() ? getSegmentGridStep() : 0;
                 const snappedValue = step > 0 ? snapScalar(rawValue, step) : rawValue;
                 const newValue = Math.max(MIN_ROOF_DIM, snappedValue);
+                const centerOffset = (side * (newValue - initialValue)) / 2;
+                const position = [
+                    initialPosition[0] + centerOffset * armX,
+                    initialPosition[1],
+                    initialPosition[2] + centerOffset * armZ,
+                ];
                 lastValue = newValue;
-                useLiveNodeOverrides
-                    .getState()
-                    .set(segmentId, axis === 'x' ? { width: newValue } : { depth: newValue });
+                const dimensions = node.roofType === 'conical'
+                    ? { width: newValue, depth: newValue }
+                    : axis === 'x'
+                        ? { width: newValue }
+                        : { depth: newValue };
+                useLiveNodeOverrides.getState().set(segmentId, { ...dimensions, position });
                 useScene.getState().markDirty(segmentId);
             },
             canCommit() {
@@ -77,9 +114,18 @@ export const roofSegmentResizeAffordance = {
             },
             commit() {
                 useLiveNodeOverrides.getState().clear(segmentId);
-                useScene
-                    .getState()
-                    .updateNode(segmentId, axis === 'x' ? { width: lastValue } : { depth: lastValue });
+                const centerOffset = (side * (lastValue - initialValue)) / 2;
+                const position = [
+                    initialPosition[0] + centerOffset * armX,
+                    initialPosition[1],
+                    initialPosition[2] + centerOffset * armZ,
+                ];
+                const dimensions = node.roofType === 'conical'
+                    ? { width: lastValue, depth: lastValue }
+                    : axis === 'x'
+                        ? { width: lastValue }
+                        : { depth: lastValue };
+                useScene.getState().updateNode(segmentId, { ...dimensions, position });
             },
         };
     },
@@ -154,7 +200,7 @@ export const roofSegmentMoveTarget = ({ node, nodes }) => {
             // Mode-aware: `getSegmentGridStep()` is 0 outside grid mode (so `lines` /
             // `off` move freely), and the `moving` scope resolves the `polygon` set
             // via the kind's `snapProfile` — no held-Shift bypass.
-            const step = getSegmentGridStep();
+            const step = isGridSnapActive() ? getSegmentGridStep() : 0;
             const snap = (value) => snapScalar(value, step);
             const worldPoint = resolveCursor(planPoint, { snap });
             const dx = worldPoint[0] - roofPosX;

package/dist/roof-segment/floorplan.d.ts

@@ -14,6 +14,7 @@ import { type FloorplanGeometry, type GeometryContext, type RoofSegmentNode } fr
 export declare function buildRoofSegmentFloorplan(node: RoofSegmentNode, ctx: GeometryContext): FloorplanGeometry | null;
 export type PlanPt = readonly [number, number];
 export type PlanSeg = readonly [PlanPt, PlanPt];
+export declare function getConicalRoofPlanFootprint(node: RoofSegmentNode): PlanPt[];
 /**
  * Ridge / hip / break linework for a roof segment in segment-local space
  * (lx = width axis, lz = depth axis), mirroring the faces the 3D builder
@@ -26,8 +27,8 @@ export type PlanSeg = readonly [PlanPt, PlanPt];
  * - break: horizontal fold where the slope angle changes (gambrel kink,
  *          mansard/dutch waist)
  *
- * Exported so the roof-level builder can reuse it to terminate the valley
- * diagonals it draws at merged-roof junctions against the segments' ridges.
+ * Exported so the roof-level builder can reuse the same architectural
+ * linework for the complete roof plan.
  */
 export declare function getRoofSegmentPlanLinework(node: RoofSegmentNode): {
     ridges: PlanSeg[];

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof-segment/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAGpB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAyJ1B;AAED,MAAM,MAAM,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC9C,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE/C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,eAAe,GAAG;IACjE,MAAM,EAAE,OAAO,EAAE,CAAA;IACjB,IAAI,EAAE,OAAO,EAAE,CAAA;IACf,MAAM,EAAE,OAAO,EAAE,CAAA;IACjB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAC7C,CAwGA"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof-segment/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAiM1B;AAED,MAAM,MAAM,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC9C,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE/C,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,EAAE,CAY3E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,eAAe,GAAG;IACjE,MAAM,EAAE,OAAO,EAAE,CAAA;IACjB,IAAI,EAAE,OAAO,EAAE,CAAA;IACf,MAAM,EAAE,OAAO,EAAE,CAAA;IACjB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAC7C,CAyGA"}

package/dist/roof-segment/floorplan.js

@@ -1,4 +1,4 @@
-import { getDutchRoofMetrics, } from '@pascal-app/core';
+import { getConicalRoofCoverage, getDutchRoofMetrics, } from '@pascal-app/core';
 /**
  * Stage C floor-plan builder for roof segment. Renders the segment as a
  * proper architectural roof plan: the footprint outline plus the
@@ -39,6 +39,8 @@ export function buildRoofSegmentFloorplan(node, ctx) {
         cx + lx * cos - lz * sin,
         cz + lx * sin + lz * cos,
     ];
+    const conicalFootprint = getConicalRoofPlanFootprint(node).map(([x, z]) => toPlan(x, z));
+    const isFullCone = getConicalRoofCoverage(node).fullCircle;
     const corners = [
         [-halfWidth, -halfDepth],
         [halfWidth, -halfDepth],
@@ -56,19 +58,32 @@ export function buildRoofSegmentFloorplan(node, ctx) {
     // the same in the floor plan.
     const baseInk = '#111111';
     const stroke = showSelectedChrome && palette ? palette.selectedStroke : baseInk;
-    const children = [
-        // Invisible hit-target — full footprint, transparent fill, captures
-        // clicks across the entire roof rectangle (so the user doesn't need
-        // to pixel-hunt the outline strokes).
-        {
+    const footprint = node.roofType === 'conical' && isFullCone
+        ? {
+            kind: 'circle',
+            cx,
+            cy: cz,
+            r: halfWidth,
+            fill: stroke,
+            fillOpacity: 0,
+            stroke: 'none',
+            strokeWidth: 0,
+            pointerEvents: 'all',
+        }
+        : {
             kind: 'polygon',
-            points,
+            points: node.roofType === 'conical' ? conicalFootprint : points,
             fill: stroke,
             fillOpacity: 0,
             stroke: 'none',
             strokeWidth: 0,
             pointerEvents: 'all',
-        },
+        };
+    const children = [
+        // Invisible hit-target — full footprint, transparent fill, captures
+        // clicks across the entire roof rectangle (so the user doesn't need
+        // to pixel-hunt the outline strokes).
+        footprint,
     ];
     // The segment's own rectangle outline + fill render ONLY while it's
     // selected / highlighted — that highlights which sub-plane is active
@@ -77,26 +92,34 @@ export function buildRoofSegmentFloorplan(node, ctx) {
     // (`buildRoofFloorplan`), so overlapping segments read as one combined
     // shape instead of stacked rectangles. Ridges/hips below always draw.
     if (showSelectedChrome) {
-        children.push({
-            kind: 'polygon',
-            points,
-            fill: '#fed7aa',
-            fillOpacity: 0.55,
-            stroke,
-            strokeWidth: 0.035,
-            strokeLinejoin: 'miter',
-        });
+        children.push(node.roofType === 'conical' && isFullCone
+            ? {
+                kind: 'circle',
+                cx,
+                cy: cz,
+                r: halfWidth,
+                fill: '#fed7aa',
+                fillOpacity: 0.55,
+                stroke,
+                strokeWidth: 0.035,
+            }
+            : {
+                kind: 'polygon',
+                points: node.roofType === 'conical' ? conicalFootprint : points,
+                fill: '#fed7aa',
+                fillOpacity: 0.55,
+                stroke,
+                strokeWidth: 0.035,
+                strokeLinejoin: 'miter',
+            });
     }
     // NOTE: the ridge / hip / break / slope linework is NOT drawn here — the
     // parent roof's builder (`buildRoofFloorplan`) draws it for every segment,
-    // clipped against the merged-roof valleys so a segment's ridge stops at
-    // the junction instead of running on into a neighbour it overlaps. This
-    // builder owns only the per-segment interaction chrome below. The shape
-    // math lives in `getRoofSegmentPlanLinework` (exported for the roof
-    // builder to consume).
-    // Selection chrome — orange move-handle dot at the centre, four
-    // perpendicular side resize-arrows (width on X, depth on Z), and a
-    // rotate-arrow at the +X/+Z corner. Sister to the 3D handles in
+    // while this builder owns only the per-segment interaction chrome below.
+    // The shape math lives in `getRoofSegmentPlanLinework` (exported for the
+    // roof builder to consume).
+    // Selection chrome — orange move-handle dot at the centre, footprint
+    // resize arrows, and a rotate-arrow at the +X/+Z corner. Sister to the 3D handles in
     // `definition.ts`. Resize/rotate route through the matching
     // `floorplanAffordances`; the dot drives body-move via
     // `def.floorplanMoveTarget`.
@@ -116,38 +139,63 @@ export function buildRoofSegmentFloorplan(node, ctx) {
             lx * cos - ly * sin,
             lx * sin + ly * cos,
         ];
-        const sides = [
-            { local: [halfW + sideArrowOffset, 0], localAngle: 0, axis: 'x', side: 1 },
-            { local: [-(halfW + sideArrowOffset), 0], localAngle: Math.PI, axis: 'x', side: -1 },
-            { local: [0, halfD + sideArrowOffset], localAngle: Math.PI / 2, axis: 'z', side: 1 },
-            { local: [0, -(halfD + sideArrowOffset)], localAngle: -Math.PI / 2, axis: 'z', side: -1 },
-        ];
-        for (const s of sides) {
-            const [ox, oz] = rotateLocal(s.local[0], s.local[1]);
-            const [tx, tz] = rotateLocal(Math.cos(s.localAngle), Math.sin(s.localAngle));
+        if (node.roofType === 'conical') {
+            const [ox, oz] = rotateLocal(halfW + sideArrowOffset, 0);
+            const [tx, tz] = rotateLocal(1, 0);
             children.push({
                 kind: 'move-arrow',
                 point: [cx + ox, cz + oz],
                 angle: Math.atan2(tz, tx),
                 affordance: 'roof-segment-resize',
-                payload: { axis: s.axis, side: s.side },
+                payload: { mode: 'radial' },
             });
         }
+        else {
+            const sides = [
+                { local: [halfW + sideArrowOffset, 0], localAngle: 0, axis: 'x', side: 1 },
+                { local: [-(halfW + sideArrowOffset), 0], localAngle: Math.PI, axis: 'x', side: -1 },
+                { local: [0, halfD + sideArrowOffset], localAngle: Math.PI / 2, axis: 'z', side: 1 },
+                { local: [0, -(halfD + sideArrowOffset)], localAngle: -Math.PI / 2, axis: 'z', side: -1 },
+            ];
+            for (const side of sides) {
+                const [ox, oz] = rotateLocal(side.local[0], side.local[1]);
+                const [tx, tz] = rotateLocal(Math.cos(side.localAngle), Math.sin(side.localAngle));
+                children.push({
+                    kind: 'move-arrow',
+                    point: [cx + ox, cz + oz],
+                    angle: Math.atan2(tz, tx),
+                    affordance: 'roof-segment-resize',
+                    payload: { axis: side.axis, side: side.side },
+                });
+            }
+        }
         // Rotate-arrow at the +X / +Z corner. Local angle π/4 puts the
         // curved arrow's bow at the diagonal corner so it reads as a
         // rotation gizmo around the segment centre.
-        const [cornerX, cornerZ] = rotateLocal(halfW + rotateCornerOffset, halfD + rotateCornerOffset);
-        const [radialX, radialZ] = rotateLocal(1, 1);
-        children.push({
-            kind: 'rotate-arrow',
-            point: [cx + cornerX, cz + cornerZ],
-            angle: Math.atan2(radialZ, radialX),
-            affordance: 'roof-segment-rotate',
-            pivot: [cx, cz],
-        });
+        if (node.roofType !== 'conical') {
+            const [cornerX, cornerZ] = rotateLocal(halfW + rotateCornerOffset, halfD + rotateCornerOffset);
+            const [radialX, radialZ] = rotateLocal(1, 1);
+            children.push({
+                kind: 'rotate-arrow',
+                point: [cx + cornerX, cz + cornerZ],
+                angle: Math.atan2(radialZ, radialX),
+                affordance: 'roof-segment-rotate',
+                pivot: [cx, cz],
+            });
+        }
     }
     return { kind: 'group', children };
 }
+export function getConicalRoofPlanFootprint(node) {
+    const coverage = getConicalRoofCoverage(node);
+    const sweep = Math.max(-Math.PI * 2, Math.min(Math.PI * 2, Math.abs(coverage.sweepAngle) < 1e-4 ? 1e-4 : coverage.sweepAngle));
+    const count = Math.max(1, Math.ceil((48 * Math.abs(sweep)) / (Math.PI * 2)));
+    const arc = Array.from({ length: count + 1 }, (_, index) => {
+        const angle = coverage.startAngle + (index / count) * sweep;
+        return [Math.cos(angle) * (node.width / 2), Math.sin(angle) * (node.width / 2)];
+    });
+    return Math.abs(sweep) >= Math.PI * 2 - 1e-4 ? arc.slice(0, -1) : [[0, 0], ...arc];
+}
 /**
  * Ridge / hip / break linework for a roof segment in segment-local space
  * (lx = width axis, lz = depth axis), mirroring the faces the 3D builder
@@ -160,8 +208,8 @@ export function buildRoofSegmentFloorplan(node, ctx) {
  * - break: horizontal fold where the slope angle changes (gambrel kink,
  *          mansard/dutch waist)
  *
- * Exported so the roof-level builder can reuse it to terminate the valley
- * diagonals it draws at merged-roof junctions against the segments' ridges.
+ * Exported so the roof-level builder can reuse the same architectural
+ * linework for the complete roof plan.
  */
 export function getRoofSegmentPlanLinework(node) {
     const hw = node.width / 2;
@@ -197,6 +245,7 @@ export function getRoofSegmentPlanLinework(node) {
         }
     };
     switch (node.roofType) {
+        case 'conical':
         case 'flat':
             break;
         case 'gable':

package/dist/roof-segment/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/roof-segment/panel.tsx"],"names":[],"mappings":"AA8DA,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCAgfvC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/roof-segment/panel.tsx"],"names":[],"mappings":"AAkGA,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCA4oBvC"}