@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/roof-segment/definition.edit.js

@@ -0,0 +1,305 @@
+import { getActiveRoofHeight, getPitchFromActiveRoofHeight, getRoofSegmentResizePatch, MAX_ROOF_PITCH, MIN_ROOF_SEGMENT_DIMENSION, snapScalar, } from '@pascal-app/core';
+import { getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, PANEL_MODEL_EXTENSION, } from '@pascal-app/editor';
+import { roofFloorplanAffectedIds } from '../roof/floorplan-overrides.js';
+import { bearingWallThickness, catchRoofSideOnWalls, roofCatchWalls, segmentWallLine, } from '../roof/wall-catch.js';
+import { buildRoofSegmentFloorplan } from './floorplan.js';
+import { roofSegmentMoveTarget, roofSegmentResizeAffordance, roofSegmentRotateAffordance, } from './floorplan-affordances.js';
+import { roofSegmentPaint } from './paint.js';
+import { roofSegmentPanelModel } from './panel-model.js';
+import { roofSegmentParametrics } from './parametrics.js';
+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 = MIN_ROOF_SEGMENT_DIMENSION;
+const MIN_WALL_HEIGHT = 0;
+// Clamp used for handle Y placement so arrows stay visible on flat /
+// wall-less segments where `wallHeight ≈ 0` would put them on the floor.
+const MIN_WALL_DISPLAY = 0.3;
+// Pitch is stored in degrees on the schema; same clamp the panel applies.
+const MIN_PITCH = 0;
+const MAX_PITCH = MAX_ROOF_PITCH;
+// Floor-to-peak height of the assembled segment. Pitch drag drives this
+// value directly and back-solves the pitch angle via the slope-frame
+// math in core.
+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;
+}
+function roofOf(n, sceneApi) {
+    const roof = n.parentId ? sceneApi?.get(n.parentId) : undefined;
+    return roof?.type === 'roof' ? roof : undefined;
+}
+// A dragged side lands on a wall under it in grid and lines, ahead of the grid, as a move does.
+// The arrows leave `gridSnap` off so the catch sees the raw size, and grid it here when nothing
+// catches; Alt skips this hook, so the side follows the cursor.
+function snapSideOntoWalls(axis, side) {
+    return (n, value, sceneApi) => {
+        const grid = isGridSnapActive();
+        if (!grid && !isMagneticSnapActive())
+            return value;
+        const roof = roofOf(n, sceneApi);
+        if (roof) {
+            const caught = catchRoofSideOnWalls({
+                line: segmentWallLine(roof, n),
+                axis,
+                side,
+                value,
+                walls: roofCatchWalls(sceneApi.nodes(), roof.parentId),
+            });
+            if (caught !== null)
+                return caught;
+        }
+        return grid ? snapScalar(value, getSegmentGridStep()) : value;
+    };
+}
+// Sized onto the walls under it, a segment's gable and heel walls take their thickness; off them,
+// its own (written either way, so a drag back off the walls drops the thickness it previewed).
+function onBearingWalls(n, patch, sceneApi) {
+    const roof = roofOf(n, sceneApi);
+    if (!(roof && sceneApi))
+        return patch;
+    const thickness = bearingWallThickness(segmentWallLine(roof, { ...n, ...patch }), roofCatchWalls(sceneApi.nodes(), roof.parentId));
+    return { ...patch, wallThickness: thickness ?? n.wallThickness };
+}
+// 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
+// (`door/definition.ts:35-73`). The arrow's chevron points outward
+// (`rotationY: Math.PI` flips the left arrow's chevron to face -X) so
+// you read "this edge is what moves" at a glance.
+//
+// `apply` recomputes `position` so the anchored edge stays at the same
+// world point even when the segment is Y-rotated: project the segment's
+// local +X onto world via (cos r, -sin r), find the anchored edge's
+// world XZ from the pre-drag node, then place the new center half a
+// new-width away from that anchor in the same direction.
+function roofSegmentWidthHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        // 'min' = -X edge anchored (right arrow grows the +X edge outward).
+        // 'max' = +X edge anchored (left arrow grows the -X edge outward).
+        anchor: side === 'right' ? 'min' : 'max',
+        min: MIN_ROOF_DIM,
+        connectionSnap: snapSideOntoWalls('x', sign),
+        currentValue: (n) => n.width,
+        apply: (initial, newWidth, sceneApi) => onBearingWalls(initial, getRoofSegmentResizePatch(initial, 'x', sign, newWidth), sceneApi),
+        placement: {
+            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.
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+    };
+}
+// Depth arrow on the +Z (front) or -Z (back) side. Asymmetric: the
+// dragged edge follows the pointer, the opposite edge stays world-fixed
+// — mirrors the width-handle pattern (`roofSegmentWidthHandle`). Because
+// segment depth feeds the pitch math via `getActiveRoofHeight`, growing
+// depth at constant pitch ramps the peak up too, which reads as
+// scaling. We hold the peak height constant by back-solving a new pitch
+// for the new depth (same recipe the pitch handle uses, run in
+// reverse). MIN/MAX_PITCH clamps cover degenerate cases where the new
+// depth would demand a negative or beyond-vertical pitch.
+function roofSegmentDepthHandle(side) {
+    const sign = side === 'front' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: side === 'front' ? 'min' : 'max',
+        min: MIN_ROOF_DIM,
+        connectionSnap: snapSideOntoWalls('z', sign),
+        currentValue: (n) => n.depth,
+        apply: (initial, newDepth, sceneApi) => onBearingWalls(initial, getRoofSegmentResizePatch(initial, 'z', sign, newDepth), sceneApi),
+        placement: {
+            position: (n) => [
+                0,
+                getSideResizeHandleY(n, sign * (n.depth / 2)),
+                sign * (n.depth / 2 + SIDE_HANDLE_OFFSET),
+            ],
+            // For axis 'z', `LinearArrow` adds -π/2 around Y so the chevron
+            // points +Z by default. Flip the back arrow by π so it points -Z.
+            rotationY: () => (side === 'front' ? 0 : Math.PI),
+        },
+    };
+}
+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
+// THIS tall" instead of "there's an arrow on the side." Drag math is
+// unchanged: same linear-resize axis='y' / anchor='min' pipeline as
+// every other height handle; the `shape: 'tracker'` flag only swaps the
+// visual. Wall-height clamps to MIN_WALL_DISPLAY for placement so the
+// cube stays grabbable on flat / wall-less segments where the real
+// `wallHeight` is ~0 and the leader would collapse to nothing.
+function roofSegmentWallHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        shape: 'tracker',
+        min: MIN_WALL_HEIGHT,
+        gridSnap: true,
+        currentValue: (n) => n.wallHeight,
+        apply: (_n, newValue) => ({ wallHeight: newValue }),
+        placement: {
+            position: (n) => [0, Math.max(n.wallHeight, MIN_WALL_DISPLAY), 0],
+        },
+    };
+}
+// Pitch arrow — drag the peak vertically to steepen / flatten the roof.
+// The handle exposes the floor-to-peak height as its currentValue so the
+// drag delta is a meters value the user can read in the dimension chip;
+// `apply` inverts the slope-frame math (run = primary-slope footprint
+// span, rise fraction depends on roofType) to recover the pitch degrees
+// the new peak corresponds to. Clamped to the schema range [0, 85].
+//
+// Placed at the peak's center so it visually attaches to the ridge for
+// gable / hip / dutch / mansard / gambrel; on shed roofs the geometric
+// peak sits at one edge, so the arrow floats slightly inboard of the
+// ridge — acceptable as a "peak-height" affordance and matches the
+// floorplan-center origin every other handle uses.
+function roofSegmentPitchHandle() {
+    return {
+        kind: 'linear-resize',
+        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);
+            if (initial.roofType === 'barrel')
+                return { barrelRise: Math.max(0.01, Math.min(initial.depth / 2, roofHeight)) };
+            const pitch = getPitchFromActiveRoofHeight({
+                roofType: initial.roofType,
+                width: initial.width,
+                depth: initial.depth,
+                roofHeight,
+                gambrelLowerWidthRatio: initial.gambrelLowerWidthRatio,
+                gambrelLowerHeightRatio: initial.gambrelLowerHeightRatio,
+                mansardSteepWidthRatio: initial.mansardSteepWidthRatio,
+                mansardSteepHeightRatio: initial.mansardSteepHeightRatio,
+                dutchHipWidthRatio: initial.dutchHipWidthRatio,
+                dutchHipHeightRatio: initial.dutchHipHeightRatio,
+            });
+            return { pitch: Math.max(MIN_PITCH, Math.min(MAX_PITCH, pitch)) };
+        },
+        placement: {
+            position: (n) => [0, getPeakHeight(n) + HEIGHT_HANDLE_OFFSET, 0],
+        },
+    };
+}
+// Whole-segment rotation gizmo — curved two-headed arrow at the +X / +Z
+// corner of the footprint, guide ring traces the corner-diagonal radius
+// on hover / drag. Same pattern as the elevator / column rotate gizmo;
+// roof-segment stores rotation as a scalar (radians) so the apply patch
+// just writes back the new scalar.
+function roofSegmentRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        // Negate the cursor delta to match three.js Y-rotation handedness
+        // (cursor atan2 ticks opposite-handed from `rotation-y`).
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: (n) => {
+                const halfX = n.width / 2;
+                const halfZ = n.depth / 2;
+                const yMid = Math.max(n.wallHeight, MIN_WALL_DISPLAY) / 2;
+                return [halfX, yMid, halfZ + ROTATE_CORNER_OFFSET];
+            },
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            radius: (n) => Math.hypot(n.width / 2, n.depth / 2) + ROTATE_RING_OFFSET,
+            y: (n) => Math.max(n.wallHeight, MIN_WALL_DISPLAY) / 2,
+        },
+    };
+}
+const roofSegmentHandles = [
+    roofSegmentWidthHandle('right'),
+    roofSegmentWidthHandle('left'),
+    roofSegmentDepthHandle('front'),
+    roofSegmentDepthHandle('back'),
+    roofSegmentWallHeightHandle(),
+    roofSegmentPitchHandle(),
+    roofSegmentRotateHandle(),
+];
+const conicalRoofSegmentHandles = [
+    conicalRoofSegmentRadiusHandle(),
+    roofSegmentWallHeightHandle(),
+    roofSegmentPitchHandle(),
+];
+function resolveRoofSegmentHandles(node) {
+    if (node.managedByParent)
+        return [];
+    return node.roofType === 'conical' ? conicalRoofSegmentHandles : roofSegmentHandles;
+}
+export const roofSegmentEditContribution = {
+    // Mirrors the parent roof: a body-move resolves the no-angle `polygon`
+    // snap context (grid / lines / off), so dragging a segment shows the
+    // snapping chip and honours the active mode like every other structural
+    // move. Resize / rotate run through their own reshaping scope.
+    snapProfile: 'structural',
+    extensions: {
+        [PANEL_MODEL_EXTENSION]: roofSegmentPanelModel,
+    },
+    capabilities: {
+        paint: roofSegmentPaint,
+    },
+    // Bespoke move shared with roof / stair / stair-segment via
+    // `shared/move-roof-tool` — routed through `MoveTool`'s registry-
+    // affordance lookup rather than a hardcoded dispatcher arm.
+    affordanceTools: {
+        move: () => import('../shared/move-roof-tool.js'),
+    },
+    parametrics: roofSegmentParametrics,
+    handles: resolveRoofSegmentHandles,
+    floorplan: buildRoofSegmentFloorplan,
+    // Its roof draws the outline and creases from it: a live edit rebuilds that roof's plan.
+    floorplanAffectedIds: roofFloorplanAffectedIds,
+    // Body-move target. The generic Path 2 fallback writes plan coords
+    // directly to `position`, which is wrong here because the segment's
+    // position is roof-local. `roofSegmentMoveTarget` inverts the parent
+    // roof's transform so the segment lands at the world-plan cursor.
+    floorplanMoveTarget: roofSegmentMoveTarget,
+    // 2D drag affordances for the side resize arrows + corner rotate
+    // arrow emitted by `buildRoofSegmentFloorplan`.
+    floorplanAffordances: {
+        'roof-segment-resize': roofSegmentResizeAffordance,
+        'roof-segment-rotate': roofSegmentRotateAffordance,
+    },
+};

package/dist/roof-segment/definition.js

@@ -1,319 +1,4 @@
-import { getActiveRoofHeight, getPitchFromActiveRoofHeight, getRoofSegmentResizePatch, RoofSegmentNode as RoofSegmentNodeSchema, } from '@pascal-app/core';
-import { buildRoofSegmentFloorplan } from './floorplan.js';
-import { roofSegmentMoveTarget, roofSegmentResizeAffordance, roofSegmentRotateAffordance, } from './floorplan-affordances.js';
-import { matchRoofSegmentMeasurementFeature, roofSegmentMeasurementFeatures } from './measurement.js';
-import { roofSegmentPaint, roofSegmentSlots } from './paint.js';
-import { roofSegmentParametrics } from './parametrics.js';
-import { RoofSegmentNode } from './schema.js';
-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;
-const MIN_WALL_HEIGHT = 0;
-// Clamp used for handle Y placement so arrows stay visible on flat /
-// wall-less segments where `wallHeight ≈ 0` would put them on the floor.
-const MIN_WALL_DISPLAY = 0.3;
-// Pitch is stored in degrees on the schema; same clamp the panel applies.
-const MIN_PITCH = 0;
-const MAX_PITCH = 85;
-// Floor-to-peak height of the assembled segment. Pitch drag drives this
-// value directly and back-solves the pitch angle via the slope-frame
-// math in core.
-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
-// (`door/definition.ts:35-73`). The arrow's chevron points outward
-// (`rotationY: Math.PI` flips the left arrow's chevron to face -X) so
-// you read "this edge is what moves" at a glance.
-//
-// `apply` recomputes `position` so the anchored edge stays at the same
-// world point even when the segment is Y-rotated: project the segment's
-// local +X onto world via (cos r, -sin r), find the anchored edge's
-// world XZ from the pre-drag node, then place the new center half a
-// new-width away from that anchor in the same direction.
-function roofSegmentWidthHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        // 'min' = -X edge anchored (right arrow grows the +X edge outward).
-        // 'max' = +X edge anchored (left arrow grows the -X edge outward).
-        anchor: side === 'right' ? 'min' : 'max',
-        min: MIN_ROOF_DIM,
-        gridSnap: true,
-        currentValue: (n) => n.width,
-        apply: (initial, newWidth) => getRoofSegmentResizePatch(initial, 'x', sign, newWidth),
-        placement: {
-            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.
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-    };
-}
-// Depth arrow on the +Z (front) or -Z (back) side. Asymmetric: the
-// dragged edge follows the pointer, the opposite edge stays world-fixed
-// — mirrors the width-handle pattern (`roofSegmentWidthHandle`). Because
-// segment depth feeds the pitch math via `getActiveRoofHeight`, growing
-// depth at constant pitch ramps the peak up too, which reads as
-// scaling. We hold the peak height constant by back-solving a new pitch
-// for the new depth (same recipe the pitch handle uses, run in
-// reverse). MIN/MAX_PITCH clamps cover degenerate cases where the new
-// depth would demand a negative or beyond-vertical pitch.
-function roofSegmentDepthHandle(side) {
-    const sign = side === 'front' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'z',
-        anchor: side === 'front' ? 'min' : 'max',
-        min: MIN_ROOF_DIM,
-        gridSnap: true,
-        currentValue: (n) => n.depth,
-        apply: (initial, newDepth) => getRoofSegmentResizePatch(initial, 'z', sign, newDepth),
-        placement: {
-            position: (n) => [
-                0,
-                getSideResizeHandleY(n, sign * (n.depth / 2)),
-                sign * (n.depth / 2 + SIDE_HANDLE_OFFSET),
-            ],
-            // For axis 'z', `LinearArrow` adds -π/2 around Y so the chevron
-            // points +Z by default. Flip the back arrow by π so it points -Z.
-            rotationY: () => (side === 'front' ? 0 : Math.PI),
-        },
-    };
-}
-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
-// THIS tall" instead of "there's an arrow on the side." Drag math is
-// unchanged: same linear-resize axis='y' / anchor='min' pipeline as
-// every other height handle; the `shape: 'tracker'` flag only swaps the
-// visual. Wall-height clamps to MIN_WALL_DISPLAY for placement so the
-// cube stays grabbable on flat / wall-less segments where the real
-// `wallHeight` is ~0 and the leader would collapse to nothing.
-function roofSegmentWallHeightHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        shape: 'tracker',
-        min: MIN_WALL_HEIGHT,
-        gridSnap: true,
-        currentValue: (n) => n.wallHeight,
-        apply: (_n, newValue) => ({ wallHeight: newValue }),
-        placement: {
-            position: (n) => [0, Math.max(n.wallHeight, MIN_WALL_DISPLAY), 0],
-        },
-    };
-}
-// Pitch arrow — drag the peak vertically to steepen / flatten the roof.
-// The handle exposes the floor-to-peak height as its currentValue so the
-// drag delta is a meters value the user can read in the dimension chip;
-// `apply` inverts the slope-frame math (run = primary-slope footprint
-// span, rise fraction depends on roofType) to recover the pitch degrees
-// the new peak corresponds to. Clamped to the schema range [0, 85].
-//
-// Placed at the peak's center so it visually attaches to the ridge for
-// gable / hip / dutch / mansard / gambrel; on shed roofs the geometric
-// peak sits at one edge, so the arrow floats slightly inboard of the
-// ridge — acceptable as a "peak-height" affordance and matches the
-// floorplan-center origin every other handle uses.
-function roofSegmentPitchHandle() {
-    return {
-        kind: 'linear-resize',
-        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);
-            if (initial.roofType === 'barrel')
-                return { barrelRise: Math.max(0.01, Math.min(initial.depth / 2, roofHeight)) };
-            const pitch = getPitchFromActiveRoofHeight({
-                roofType: initial.roofType,
-                width: initial.width,
-                depth: initial.depth,
-                roofHeight,
-                gambrelLowerWidthRatio: initial.gambrelLowerWidthRatio,
-                gambrelLowerHeightRatio: initial.gambrelLowerHeightRatio,
-                mansardSteepWidthRatio: initial.mansardSteepWidthRatio,
-                mansardSteepHeightRatio: initial.mansardSteepHeightRatio,
-                dutchHipWidthRatio: initial.dutchHipWidthRatio,
-                dutchHipHeightRatio: initial.dutchHipHeightRatio,
-            });
-            return { pitch: Math.max(MIN_PITCH, Math.min(MAX_PITCH, pitch)) };
-        },
-        placement: {
-            position: (n) => [0, getPeakHeight(n) + HEIGHT_HANDLE_OFFSET, 0],
-        },
-    };
-}
-// Whole-segment rotation gizmo — curved two-headed arrow at the +X / +Z
-// corner of the footprint, guide ring traces the corner-diagonal radius
-// on hover / drag. Same pattern as the elevator / column rotate gizmo;
-// roof-segment stores rotation as a scalar (radians) so the apply patch
-// just writes back the new scalar.
-function roofSegmentRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        // Negate the cursor delta to match three.js Y-rotation handedness
-        // (cursor atan2 ticks opposite-handed from `rotation-y`).
-        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
-        placement: {
-            position: (n) => {
-                const halfX = n.width / 2;
-                const halfZ = n.depth / 2;
-                const yMid = Math.max(n.wallHeight, MIN_WALL_DISPLAY) / 2;
-                return [halfX, yMid, halfZ + ROTATE_CORNER_OFFSET];
-            },
-            rotationY: () => -Math.PI / 4,
-        },
-        decoration: {
-            kind: 'ring',
-            radius: (n) => Math.hypot(n.width / 2, n.depth / 2) + ROTATE_RING_OFFSET,
-            y: (n) => Math.max(n.wallHeight, MIN_WALL_DISPLAY) / 2,
-        },
-    };
-}
-const roofSegmentHandles = [
-    roofSegmentWidthHandle('right'),
-    roofSegmentWidthHandle('left'),
-    roofSegmentDepthHandle('front'),
-    roofSegmentDepthHandle('back'),
-    roofSegmentWallHeightHandle(),
-    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
- * under the parent roof's `def.system`), so the segment kind itself
- * only needs a renderer wrap.
- */
-export const roofSegmentDefinition = {
-    kind: 'roof-segment',
-    schemaVersion: 7,
-    schema: RoofSegmentNode,
-    category: 'structure',
-    surfaceRole: 'roof',
-    // Mirrors the parent roof: a body-move resolves the no-angle `polygon`
-    // snap context (grid / lines / off), so dragging a segment shows the
-    // snapping chip and honours the active mode like every other structural
-    // move. Resize / rotate run through their own reshaping scope.
-    snapProfile: 'structural',
-    defaults: () => {
-        const stub = RoofSegmentNodeSchema.parse({
-            id: 'roof-segment_default',
-            type: 'roof-segment',
-        });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        revealOnEdit: [
-            'roofType',
-            'width',
-            'depth',
-            'wallHeight',
-            'pitch',
-            'overhang',
-            'wallThickness',
-            'deckThickness',
-            'barrelRise',
-            'barrelSegments',
-            'roofSystem',
-            'glazing',
-        ],
-        paint: roofSegmentPaint,
-        slots: (node) => roofSegmentSlots(node),
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-    },
-    // Bespoke move shared with roof / stair / stair-segment via
-    // `shared/move-roof-tool` — routed through `MoveTool`'s registry-
-    // affordance lookup rather than a hardcoded dispatcher arm.
-    affordanceTools: {
-        move: () => import('../shared/move-roof-tool.js'),
-    },
-    parametrics: roofSegmentParametrics,
-    handles: resolveRoofSegmentHandles,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    floorplan: buildRoofSegmentFloorplan,
-    measurement: {
-        features: (node, ctx) => roofSegmentMeasurementFeatures(node, ctx.parent?.type === 'roof' ? ctx.parent : null),
-        match: (node, ctx, point, maxDistance) => matchRoofSegmentMeasurementFeature(node, ctx.parent?.type === 'roof' ? ctx.parent : null, point, maxDistance),
-    },
-    // Body-move target. The generic Path 2 fallback writes plan coords
-    // directly to `position`, which is wrong here because the segment's
-    // position is roof-local. `roofSegmentMoveTarget` inverts the parent
-    // roof's transform so the segment lands at the world-plan cursor.
-    floorplanMoveTarget: roofSegmentMoveTarget,
-    // 2D drag affordances for the side resize arrows + corner rotate
-    // arrow emitted by `buildRoofSegmentFloorplan`.
-    floorplanAffordances: {
-        'roof-segment-resize': roofSegmentResizeAffordance,
-        'roof-segment-rotate': roofSegmentRotateAffordance,
-    },
-    presentation: {
-        label: 'Roof Segment',
-        description: 'A single pitched plane of a parent roof.',
-        icon: { kind: 'url', src: '/icons/roof.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 101,
-    },
-    mcp: {
-        description: 'A single roof segment with polygon footprint + pitch.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { roofSegmentEditContribution } from './definition.edit.js';
+import { roofSegmentRenderDefinition } from './definition.render.js';
+export const roofSegmentDefinition = composeNodeDefinition(roofSegmentRenderDefinition, roofSegmentEditContribution);

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

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { RoofSegmentNode } from './schema.js';
+export declare const roofSegmentRenderDefinition: NodeRenderDefinition<typeof RoofSegmentNode> & {
+    kind: 'roof-segment';
+};
+//# sourceMappingURL=definition.render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/roof-segment/definition.render.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAG1C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAAC,GAAG;IACvF,IAAI,EAAE,cAAc,CAAA;CA8DrB,CAAA"}