@pascal-app/nodes 0.1.1

package/dist/roof/roof-materials.js

@@ -0,0 +1,43 @@
+import { createDefaultMaterial, createSurfaceRoleMaterial, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
+import * as THREE from 'three';
+// Production materials — match the rest of the scene (white walls, light-gray slabs).
+// Indices: 0 = Wall/Trim, 1 = Deck, 2 = Interior, 3 = Shingle
+const roofMaterialsCache = new Map();
+export function getRoofMaterials(shading = 'rendered', textures = true, colorPreset = 'clay') {
+    const cacheKey = `${shading}-${textures}-${colorPreset}`;
+    const cached = roofMaterialsCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const materials = textures
+        ? [
+            // Mirrors getRoofMaterialArray's catalog defaults (wall/trim drywall,
+            // soft-white deck + soffit, terracotta shingle) for the no-parent path.
+            resolveSlotDefaultMaterial('library:concrete-drywall', shading), // 0: Wall/Trim
+            resolveSlotDefaultMaterial('library:preset-softwhite', shading), // 1: Deck
+            resolveSlotDefaultMaterial('library:preset-softwhite', shading), // 2: Interior
+            resolveSlotDefaultMaterial('library:roof-terracottatiles', shading), // 3: Shingle
+        ]
+        : [
+            createSurfaceRoleMaterial('roof', colorPreset),
+            createSurfaceRoleMaterial('ceiling', colorPreset),
+            createSurfaceRoleMaterial('ceiling', colorPreset),
+            createSurfaceRoleMaterial('roof', colorPreset),
+        ];
+    roofMaterialsCache.set(cacheKey, materials);
+    return materials;
+}
+// Debug materials — vivid, distinct colours to identify each surface group.
+const roofDebugMaterialsCache = new Map();
+export function getRoofDebugMaterials(shading = 'rendered') {
+    const cached = roofDebugMaterialsCache.get(shading);
+    if (cached)
+        return cached;
+    const materials = [
+        createDefaultMaterial('#eaeaea', 0.8, shading, THREE.DoubleSide), // 0: Wall
+        createDefaultMaterial('#000000', 0.9, shading, THREE.FrontSide), // 1: Deck
+        createDefaultMaterial('#dddddd', 0.9, shading, THREE.DoubleSide), // 2: Interior
+        createDefaultMaterial('#4ade80', 0.9, shading, THREE.FrontSide), // 3: Shingle
+    ];
+    roofDebugMaterialsCache.set(shading, materials);
+    return materials;
+}

package/dist/roof/schema.d.ts

@@ -0,0 +1,2 @@
+export { RoofNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/roof/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/roof/schema.js

@@ -0,0 +1 @@
+export { RoofNode } from '@pascal-app/core';

package/dist/roof/system.d.ts

@@ -0,0 +1,3 @@
+import { RoofSystem } from '@pascal-app/viewer';
+export default RoofSystem;
+//# sourceMappingURL=system.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/roof/system.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAE/C,eAAe,UAAU,CAAA"}

package/dist/roof/system.js

@@ -0,0 +1,3 @@
+'use client';
+import { RoofSystem } from '@pascal-app/viewer';
+export default RoofSystem;

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

@@ -0,0 +1,10 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { RoofSegmentNode } from './schema';
+/**
+ * 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 declare const roofSegmentDefinition: NodeDefinition<typeof RoofSegmentNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +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"}

package/dist/roof-segment/definition.js

@@ -0,0 +1,305 @@
+import { getActiveRoofHeight, getPitchFromActiveRoofHeight, RoofSegmentNode as RoofSegmentNodeSchema, } from '@pascal-app/core';
+import { buildRoofSegmentFloorplan } from './floorplan';
+import { roofSegmentMoveTarget, roofSegmentResizeAffordance, roofSegmentRotateAffordance, } from './floorplan-affordances';
+import { matchRoofSegmentMeasurementFeature, roofSegmentMeasurementFeatures } from './measurement';
+import { roofSegmentParametrics } from './parametrics';
+import { RoofSegmentNode } from './schema';
+const SIDE_HANDLE_OFFSET = 0.3;
+const HEIGHT_HANDLE_OFFSET = 0.3;
+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);
+}
+// 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) => {
+            const rotY = initial.rotation ?? 0;
+            const armX = Math.cos(rotY);
+            const armZ = -Math.sin(rotY);
+            const anchorX = initial.position[0] - sign * (initial.width / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.width / 2) * armZ;
+            const newCenterX = anchorX + sign * (newWidth / 2) * armX;
+            const newCenterZ = anchorZ + sign * (newWidth / 2) * armZ;
+            return {
+                width: 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,
+            ],
+            // 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) => {
+            // Recenter so the anchored Z edge stays at the same world point.
+            // Same math as the width handle but along the Z arm: yaw maps
+            // segment-local +Z to (sin r, cos r) in world.
+            const rotY = initial.rotation ?? 0;
+            const armX = Math.sin(rotY);
+            const armZ = Math.cos(rotY);
+            const anchorX = initial.position[0] - sign * (initial.depth / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.depth / 2) * armZ;
+            const newCenterX = anchorX + sign * (newDepth / 2) * armX;
+            const newCenterZ = anchorZ + sign * (newDepth / 2) * armZ;
+            // 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);
+            const newPitch = getPitchFromActiveRoofHeight({
+                roofType: initial.roofType,
+                width: initial.width,
+                depth: newDepth,
+                roofHeight: originalRoofHeight,
+                gambrelLowerWidthRatio: initial.gambrelLowerWidthRatio,
+                gambrelLowerHeightRatio: initial.gambrelLowerHeightRatio,
+                mansardSteepWidthRatio: initial.mansardSteepWidthRatio,
+                mansardSteepHeightRatio: initial.mansardSteepHeightRatio,
+                dutchHipWidthRatio: initial.dutchHipWidthRatio,
+                dutchHipHeightRatio: initial.dutchHipHeightRatio,
+            });
+            return {
+                depth: newDepth,
+                position: [newCenterX, initial.position[1], newCenterZ],
+                pitch: Math.max(MIN_PITCH, Math.min(MAX_PITCH, newPitch)),
+            };
+        },
+        placement: {
+            position: (n) => [
+                0,
+                Math.max(n.wallHeight, MIN_WALL_DISPLAY) / 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),
+        },
+    };
+}
+// 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,
+        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,
+        currentValue: (n) => getPeakHeight(n),
+        apply: (initial, newPeakHeight) => {
+            const roofHeight = Math.max(0, newPeakHeight - initial.wallHeight);
+            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(),
+];
+/**
+ * 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: 1,
+    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: {
+        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'),
+    },
+    parametrics: roofSegmentParametrics,
+    handles: roofSegmentHandles,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    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.',
+    },
+};

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

@@ -0,0 +1,31 @@
+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.
+ */
+export declare const roofSegmentResizeAffordance: FloorplanAffordance<RoofSegmentNode>;
+/**
+ * Roof-segment rotation drag (floor-plan). Sister to the 3D `arc-resize`
+ * handle. Same `- delta` convention as the 3D handle: the floor-plan
+ * builder plots the footprint at `-(roof.rotation + segment.rotation)`
+ * (see `buildRoofSegmentFloorplan`'s `rotation` local), so the 2D
+ * view rotates the same direction as 3D for the same `rotation` value,
+ * and the same cursor gesture writes the same sign in both views.
+ */
+export declare const roofSegmentRotateAffordance: FloorplanAffordance<RoofSegmentNode>;
+/**
+ * Roof-segment body-move target (floor-plan). The generic Path 2 move
+ * fallback writes the cursor's plan position straight into `position`,
+ * which is wrong for roof segments because `position` is **roof-local**
+ * (the floorplan builder composes parent roof's transform to render).
+ * This target inverts the parent roof's transform so the segment moves
+ * to the cursor's WORLD-plan position, not to a roof-local interpretation
+ * of those world coords. Falls back to identity for orphaned segments.
+ */
+export declare const roofSegmentMoveTarget: FloorplanMoveTarget<RoofSegmentNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -0,0 +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,EAGrB,MAAM,kBAAkB,CAAA;AA4CzB;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CA8C5E,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CA4B5E,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,eAAe,CAyCtE,CAAA"}

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

@@ -0,0 +1,170 @@
+import { snapScalar, useScene, } from '@pascal-app/core';
+import { getSegmentGridStep } from '@pascal-app/editor';
+import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
+import { rotateAffordanceDelta } from '../shared/rotate-affordance';
+const MIN_ROOF_DIM = 1;
+// Resolve world-space center + effective rotation of a roof segment by
+// composing the parent roof's position + rotation with the segment's
+// local position. Mirrors the floorplan builder's transform so handles
+// and affordances stay glued to the rendered footprint.
+function resolveSegmentFrame(segment, nodes) {
+    const roofId = segment.parentId;
+    const roof = roofId ? nodes[roofId] : undefined;
+    const roofPosX = roof?.position[0] ?? 0;
+    const roofPosZ = roof?.position[2] ?? 0;
+    // Floor-plan plots at `-rotation` so SVG-CW matches Three.js-CCW (see
+    // `buildRoofSegmentFloorplan` for the rationale). This frame mirrors
+    // the builder's transform so affordance cx/cz line up with where the
+    // segment actually renders, and the cursor projection in `effRot`
+    // works in the same coord system.
+    const roofRot = -(roof?.rotation ?? 0);
+    const cosRoof = Math.cos(roofRot);
+    const sinRoof = Math.sin(roofRot);
+    const localX = segment.position[0];
+    const localZ = segment.position[2];
+    const cx = roofPosX + localX * cosRoof - localZ * sinRoof;
+    const cz = roofPosZ + localX * sinRoof + localZ * cosRoof;
+    const effRot = roofRot + -(segment.rotation ?? 0);
+    return { cx, cz, roofRot, effRot, cosRoof, sinRoof };
+}
+/**
+ * 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.
+ */
+export const roofSegmentResizeAffordance = {
+    start({ node, payload, nodes, initialPlanPoint }) {
+        const { axis, side } = payload;
+        const segmentId = node.id;
+        const initialValue = axis === 'x' ? node.width : node.depth;
+        const { cx, cz, 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
+        // (world directions of those axes are (cosEff, sinEff) and
+        // (-sinEff, cosEff)).
+        const projectLocalAxis = (px, pz) => {
+            const dx = px - cx;
+            const dz = pz - cz;
+            return axis === 'x' ? dx * cosEff + dz * sinEff : -dx * sinEff + dz * cosEff;
+        };
+        const initialLocal = projectLocalAxis(initialPlanPoint[0], initialPlanPoint[1]);
+        let lastValue = initialValue;
+        return {
+            affectedIds: [segmentId],
+            apply({ planPoint }) {
+                const currentLocal = projectLocalAxis(planPoint[0], planPoint[1]);
+                const delta = (currentLocal - initialLocal) * side;
+                const rawValue = initialValue + 2 * 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 snappedValue = step > 0 ? snapScalar(rawValue, step) : rawValue;
+                const newValue = Math.max(MIN_ROOF_DIM, snappedValue);
+                lastValue = newValue;
+                useScene
+                    .getState()
+                    .updateNode(segmentId, axis === 'x' ? { width: newValue } : { depth: newValue });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene
+                    .getState()
+                    .updateNode(segmentId, axis === 'x' ? { width: lastValue } : { depth: lastValue });
+            },
+        };
+    },
+};
+/**
+ * Roof-segment rotation drag (floor-plan). Sister to the 3D `arc-resize`
+ * handle. Same `- delta` convention as the 3D handle: the floor-plan
+ * builder plots the footprint at `-(roof.rotation + segment.rotation)`
+ * (see `buildRoofSegmentFloorplan`'s `rotation` local), so the 2D
+ * view rotates the same direction as 3D for the same `rotation` value,
+ * and the same cursor gesture writes the same sign in both views.
+ */
+export const roofSegmentRotateAffordance = {
+    start({ node, nodes, initialPlanPoint }) {
+        const segmentId = node.id;
+        const initialRotation = node.rotation ?? 0;
+        const { cx, cz } = resolveSegmentFrame(node, nodes);
+        const initialAngle = Math.atan2(initialPlanPoint[1] - cz, initialPlanPoint[0] - cx);
+        let lastRotation = initialRotation;
+        return {
+            affectedIds: [segmentId],
+            apply({ planPoint, modifiers }) {
+                const delta = rotateAffordanceDelta({
+                    center: [cx, cz],
+                    initialAngle,
+                    planPoint,
+                    free: modifiers.shiftKey,
+                });
+                lastRotation = initialRotation - delta;
+                useScene.getState().updateNode(segmentId, { rotation: lastRotation });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNode(segmentId, { rotation: lastRotation });
+            },
+        };
+    },
+};
+/**
+ * Roof-segment body-move target (floor-plan). The generic Path 2 move
+ * fallback writes the cursor's plan position straight into `position`,
+ * which is wrong for roof segments because `position` is **roof-local**
+ * (the floorplan builder composes parent roof's transform to render).
+ * This target inverts the parent roof's transform so the segment moves
+ * to the cursor's WORLD-plan position, not to a roof-local interpretation
+ * of those world coords. Falls back to identity for orphaned segments.
+ */
+export const roofSegmentMoveTarget = ({ node, nodes }) => {
+    const segmentId = node.id;
+    const initialY = node.position[1];
+    const { cx, cz, roofRot, cosRoof, sinRoof } = resolveSegmentFrame(node, nodes);
+    const roofId = node.parentId;
+    const roof = roofId ? nodes[roofId] : undefined;
+    const roofPosX = roof?.position[0] ?? 0;
+    const roofPosZ = roof?.position[2] ?? 0;
+    const resolveCursor = createFloorplanCursorResolver({
+        original: [cx, cz],
+        metadata: node.metadata,
+    });
+    // Inverse of the forward transform `[cosRoof, -sinRoof; sinRoof, cosRoof]`
+    // is `[cosRoof, sinRoof; -sinRoof, cosRoof]`. Used to project world cursor
+    // back into roof-local coords.
+    void roofRot;
+    let lastLocal = [node.position[0], node.position[1], node.position[2]];
+    return {
+        affectedIds: [segmentId],
+        apply({ planPoint }) {
+            // 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 snap = (value) => snapScalar(value, step);
+            const worldPoint = resolveCursor(planPoint, { snap });
+            const dx = worldPoint[0] - roofPosX;
+            const dz = worldPoint[1] - roofPosZ;
+            let localX = dx * cosRoof + dz * sinRoof;
+            let localZ = -dx * sinRoof + dz * cosRoof;
+            lastLocal = [localX, initialY, localZ];
+            useScene.getState().updateNode(segmentId, { position: lastLocal });
+        },
+        canCommit() {
+            return true;
+        },
+        commit() {
+            useScene.getState().updateNode(segmentId, { position: lastLocal });
+        },
+    };
+};

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

@@ -0,0 +1,41 @@
+import { type FloorplanGeometry, type GeometryContext, type RoofSegmentNode } 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
+ * ridge / hip / break linework (and a downslope arrow for sheds) that
+ * makes each roof shape — hip, gable, shed, gambrel, dutch, mansard,
+ * flat — read distinctly, rather than as a bare rectangle.
+ *
+ * All linework is derived in segment-local space, mirroring the faces the
+ * 3D builder (`getModuleFaces` in the roof system) generates per type, so
+ * the plan and the model agree. Everything is composed into world coords
+ * via the parent roof's position + rotation and the segment's own.
+ */
+export declare function buildRoofSegmentFloorplan(node: RoofSegmentNode, ctx: GeometryContext): FloorplanGeometry | null;
+export type PlanPt = readonly [number, number];
+export type PlanSeg = readonly [PlanPt, 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
+ * (`getModuleFaces`) generates for each roof type. The floor-plan builder
+ * maps these to world coords. `slope`, when set, is a shed roof's downhill
+ * fall direction (tail = high eave, head = low eave).
+ *
+ * - ridge: peak line(s) where opposite slopes meet
+ * - hip:   diagonal from an eave corner up to a ridge end / peak
+ * - 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.
+ */
+export declare function getRoofSegmentPlanLinework(node: RoofSegmentNode): {
+    ridges: PlanSeg[];
+    hips: PlanSeg[];
+    breaks: PlanSeg[];
+    slope: {
+        tail: PlanPt;
+        head: PlanPt;
+    } | null;
+};
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +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"}