@pascal-app/nodes 0.1.1

package/dist/ridge-vent/renderer.js

@@ -0,0 +1,205 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getEffectiveRoofSurfaceMaterial, getEffectiveSegmentSurfaceMaterial, 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';
+import { RIDGE_LIFT, resolveRidgeSnap } from '../shared/ridge-snap';
+import { getRoofTopSurfaceY } from '../shared/roof-surface';
+import { useSegmentTrimClippedGeometry } from '../shared/use-segment-trim-clip';
+import { buildRidgeVentGeometry } from './geometry';
+function ridgeVentSegmentGeometryKey(segment) {
+    if (!segment)
+        return 'none';
+    const trim = segment.trim;
+    return [
+        segment.roofType,
+        segment.width,
+        segment.depth,
+        segment.wallHeight,
+        segment.pitch,
+        segment.wallThickness,
+        segment.deckThickness,
+        segment.overhang,
+        segment.shingleThickness,
+        segment.gambrelLowerWidthRatio,
+        segment.gambrelLowerHeightRatio,
+        segment.mansardSteepWidthRatio,
+        segment.mansardSteepHeightRatio,
+        segment.dutchHipWidthRatio,
+        segment.dutchHipHeightRatio,
+        trim.left,
+        trim.right,
+        trim.front,
+        trim.back,
+        trim.frontLeft,
+        trim.frontRight,
+        trim.backLeft,
+        trim.backRight,
+        trim.frontLeftX,
+        trim.frontLeftZ,
+        trim.frontRightX,
+        trim.frontRightZ,
+        trim.backLeftX,
+        trim.backLeftZ,
+        trim.backRightX,
+        trim.backRightZ,
+    ].join('|');
+}
+/**
+ * Ridge vent renderer. Sits along the ridge of a roof-segment — no
+ * slope tilt is needed (the ridge IS the high line of the segment), so
+ * the transform stack is simply
+ *
+ *   segment.position → segment.rotation (Y) → vent.position
+ *     → vent.rotation (Y) → mesh
+ *
+ * Mirrors the box-vent renderer otherwise (segment lookup via
+ * useScene, live-transform follow for parent drags). Style-specific
+ * default materials let unpainted ridge vents read as their material
+ * family (matte standard / shingled grey / brushed metal) before the
+ * user opens the paint tray.
+ */
+const RidgeVentRenderer = ({ node: storeNode }) => {
+    const ref = useRef(null);
+    useRegistry(storeNode.id, 'ridge-vent', ref);
+    const handlers = useNodeEvents(storeNode, 'ridge-vent');
+    const shading = useViewer((s) => s.shading);
+    const textures = useViewer((s) => s.textures);
+    const colorPreset = useViewer((s) => s.colorPreset);
+    const sceneTheme = useViewer((s) => s.sceneTheme);
+    // Merge live drag overrides on top of the store node so handle drags
+    // update the mesh in-flight without flushing to zustand on every frame.
+    // Same pattern as box-vent / chimney / dormer — the override is set by
+    // `NodeArrowHandles`' drag handler and cleared on commit.
+    const overrides = useLiveNodeOverrides((s) => s.get(storeNode.id));
+    const node = overrides
+        ? { ...storeNode, ...overrides }
+        : storeNode;
+    const nodePosition = node.position ?? [0, 0, 0];
+    const segmentStore = useScene((state) => node.roofSegmentId
+        ? state.nodes[node.roofSegmentId]
+        : undefined);
+    // Subscribe to the segment's live overrides too — when the user drags a
+    // segment handle (width / depth / wallHeight / pitch / rotation), the
+    // dimensions stream through `useLiveNodeOverrides` and don't hit the
+    // store until release. Merging them lets the ridge ride the segment in
+    // real time instead of snapping into place on commit.
+    const segmentOverrides = useLiveNodeOverrides((s) => node.roofSegmentId
+        ? s.get(node.roofSegmentId)
+        : undefined);
+    const segment = segmentStore
+        ? segmentOverrides
+            ? { ...segmentStore, ...segmentOverrides }
+            : segmentStore
+        : undefined;
+    const parentRoof = useScene((state) => segmentStore?.parentId
+        ? state.nodes[segmentStore.parentId]
+        : undefined);
+    const segmentGeometryKey = ridgeVentSegmentGeometryKey(segment);
+    const rotationY = node.rotation ?? 0;
+    const snap = useMemo(() => segment && Math.abs(rotationY) < 1e-5
+        ? resolveRidgeSnap(segment, nodePosition[0] ?? 0, nodePosition[2] ?? 0)
+        : null, [segment, rotationY, nodePosition[0], nodePosition[2]]);
+    const ridgeX = snap ? snap.localX : (nodePosition[0] ?? 0);
+    const ridgeZ = snap ? snap.localZ : (nodePosition[2] ?? 0);
+    const effectiveNode = useMemo(() => ({
+        ...node,
+        position: [ridgeX, nodePosition[1] ?? 0, ridgeZ],
+    }), [node, ridgeX, ridgeZ, nodePosition[1]]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: `segmentGeometryKey` captures the segment fields that affect the generated mesh; depending on the whole segment would rebuild on unrelated node changes.
+    const geometry = useMemo(() => buildRidgeVentGeometry(effectiveNode, segment), [
+        effectiveNode.length,
+        effectiveNode.width,
+        effectiveNode.height,
+        effectiveNode.style,
+        effectiveNode.endCaps,
+        effectiveNode.rotation,
+        effectiveNode.position[0],
+        effectiveNode.position[2],
+        segmentGeometryKey,
+    ]);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    // Paint surface: FrontSide everywhere — DoubleSide on the role
+    // material's NodeMaterial poisons the MRT scene pass (see `materials.ts`
+    // line 77 / glazing fix 9400f1c5). Earlier this path forced DoubleSide
+    // so the underside of the thin extruded ridge cap stayed visible from
+    // below; that's now a known visual tradeoff — building the cap as a
+    // closed solid in `geometry.ts` is the right fix if the underside-view
+    // becomes noticeable.
+    const material = useMemo(() => {
+        const createDefaultTopMaterial = () => {
+            const parentSpec = parentRoof ? getEffectiveRoofSurfaceMaterial(parentRoof, 'top') : undefined;
+            const spec = segment ? getEffectiveSegmentSurfaceMaterial(segment, 'top', parentSpec) : null;
+            if (typeof spec?.materialPreset === 'string') {
+                const resolved = createMaterialFromPresetRef(spec.materialPreset, shading);
+                if (resolved)
+                    return resolved;
+            }
+            if (spec?.material !== undefined) {
+                return createMaterial(spec.material, shading);
+            }
+            const roofMaterials = parentRoof
+                ? getRoofMaterialArray(parentRoof, shading, textures, colorPreset, sceneTheme)
+                : null;
+            return (roofMaterials?.[3] ??
+                createSurfaceRoleMaterial('roof', colorPreset, THREE.FrontSide, sceneTheme));
+        };
+        if (node.material) {
+            return createMaterial(node.material, shading);
+        }
+        if (node.materialPreset) {
+            return createMaterialFromPresetRef(node.materialPreset, shading) ?? createDefaultTopMaterial();
+        }
+        return createDefaultTopMaterial();
+    }, [
+        textures,
+        colorPreset,
+        sceneTheme,
+        shading,
+        node.material,
+        node.materialPreset,
+        segment,
+        parentRoof,
+    ]);
+    // Map vent-local geometry into the host segment's local frame (where the trim
+    // cut prisms live). Recompose the same pose the inner mesh group is mounted
+    // with — ridge snap for X/Z, slope-locked base Y + offset, yaw — so the clip
+    // matches the rendered placement. Computed before the early return so the
+    // hook order stays stable.
+    const localToSegment = useMemo(() => {
+        if (!segment)
+            return new THREE.Matrix4();
+        const baseY = getRoofTopSurfaceY(ridgeX, ridgeZ, segment);
+        const yOffset = Math.max(-2, Math.min(2, nodePosition[1] ?? 0));
+        const ridgeY = baseY + RIDGE_LIFT + yOffset;
+        return new THREE.Matrix4().compose(new THREE.Vector3(ridgeX, ridgeY, ridgeZ), new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), rotationY), new THREE.Vector3(1, 1, 1));
+    }, [segment, ridgeX, ridgeZ, rotationY, nodePosition[1]]);
+    const clippedGeometry = useSegmentTrimClippedGeometry(geometry, segment, localToSegment);
+    if (!segment)
+        return null;
+    // `node.position` is segment-local (placement / move tools resolve the
+    // click via `segObj.worldToLocal`), but the renderer mounts in the
+    // roof's `roof-elements` group — which only carries the roof's
+    // transform, not the segment's. Replicate the segment's roof-local
+    // transform here so segment-local coords land at the correct world
+    // point on every segment. Without this wrapper, ridge vents placed on
+    // a non-origin / rotated segment (e.g. the back slope of a gable, or
+    // any face of a hip) appeared on the first segment instead — the
+    // "same segment" duplication bug.
+    const segPos = segment.position ?? [0, 0, 0];
+    const segRotY = segment.rotation ?? 0;
+    // Lock the BASE position to the rendered roof skin so the vent always starts
+    // on the roof structure; treat `position[1]` and `position[2]` as user-tunable OFFSETS
+    // off that base (Y above the surface, Z away from ridge centerline). So
+    // after placement the inspector's Y / Z sliders nudge the vent off the
+    // locked ridge without losing the slope-tracking base. X is the position
+    // along the ridge — the snap re-clamps it to the segment's ridge span.
+    const baseY = getRoofTopSurfaceY(ridgeX, ridgeZ, segment);
+    // Clamp legacy stored Y (absolute peak height from earlier versions) so the
+    // vent doesn't fly off when the field was an absolute Y instead of offset.
+    const yOffset = Math.max(-2, Math.min(2, nodePosition[1] ?? 0));
+    const ridgeY = baseY + RIDGE_LIFT + yOffset;
+    return (_jsx("group", { position: segPos, "rotation-y": segRotY, children: _jsx("group", { position: [ridgeX, ridgeY, ridgeZ], ref: ref, "rotation-y": rotationY, visible: node.visible, children: _jsx("mesh", { castShadow: true, geometry: clippedGeometry ?? geometry, material: material, name: "ridge-vent-surface", receiveShadow: true, ...handlers }) }) }));
+};
+export default RidgeVentRenderer;

package/dist/ridge-vent/schema.d.ts

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

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

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

package/dist/ridge-vent/schema.js

@@ -0,0 +1,2 @@
+// Schema lives in core (referenced by the AnyNode union).
+export { RidgeVentNode } from '@pascal-app/core';

package/dist/ridge-vent/tool.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ridge vent placement tool. The cursor preview snaps to the nearest
+ * ridge/break line of whichever segment is under the cursor, since the
+ * cap needs to straddle a real roof crease.
+ */
+declare const RidgeVentTool: () => import("react").JSX.Element;
+export default RidgeVentTool;
+//# sourceMappingURL=tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/tool.tsx"],"names":[],"mappings":"AA6BA;;;;GAIG;AACH,QAAA,MAAM,aAAa,mCA0JlB,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/ridge-vent/tool.js

@@ -0,0 +1,130 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, RidgeVentNode, sceneRegistry, useScene, } from '@pascal-app/core';
+import { triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import * as THREE from 'three';
+import { resolveRidgeSnap } from '../shared/ridge-snap';
+import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
+import { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
+import { getRoofTopSurfaceY } from '../shared/roof-surface';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides';
+import { ridgeVentDefinition } from './definition';
+import RidgeVentPreview from './preview';
+const worldPoint = new THREE.Vector3();
+/**
+ * Ridge vent placement tool. The cursor preview snaps to the nearest
+ * ridge/break line of whichever segment is under the cursor, since the
+ * cap needs to straddle a real roof crease.
+ */
+const RidgeVentTool = () => {
+    const activeBuildingId = useViewer((s) => s.selection.buildingId);
+    const setSelection = useViewer((s) => s.setSelection);
+    const [previewPos, setPreviewPos] = useState(null);
+    const [previewYaw, setPreviewYaw] = useState(0);
+    const lastSnapRef = useRef(null);
+    const previewNode = useMemo(() => RidgeVentNode.parse({
+        ...ridgeVentDefinition.defaults(),
+        name: 'Ridge Vent',
+        position: [0, 0, 0],
+        rotation: 0,
+    }), []);
+    useEffect(() => {
+        if (!activeBuildingId)
+            return;
+        const worldToBuildingLocal = (wx, wy, wz) => {
+            const buildingObj = sceneRegistry.nodes.get(activeBuildingId);
+            if (!buildingObj)
+                return [wx, wy, wz];
+            worldPoint.set(wx, wy, wz);
+            buildingObj.worldToLocal(worldPoint);
+            return [worldPoint.x, worldPoint.y, worldPoint.z];
+        };
+        const updatePreview = (event) => {
+            const hit = resolveRoofSegmentHit(event.node, event.position[0], event.position[1], event.position[2]);
+            if (!hit)
+                return;
+            // Project the cursor onto the nearest segment ridge/break line.
+            // The preview then moves along that line as the cursor moves — never
+            // off it. Flat segments have no ridge: hide.
+            const snap = resolveRidgeSnap(hit.segment, hit.localX, hit.localZ);
+            if (!snap) {
+                setPreviewPos(null);
+                clearRoofSurfacePlacementGuides();
+                return;
+            }
+            const segObj = sceneRegistry.nodes.get(hit.segment.id);
+            let ridgeWorld;
+            if (segObj) {
+                const ridgeLocal = new THREE.Vector3(snap.localX, getRoofTopSurfaceY(snap.localX, snap.localZ, hit.segment), snap.localZ);
+                segObj.updateWorldMatrix(true, false);
+                ridgeLocal.applyMatrix4(segObj.matrixWorld);
+                ridgeWorld = [ridgeLocal.x, ridgeLocal.y, ridgeLocal.z];
+            }
+            else {
+                ridgeWorld = [event.position[0], event.position[1], event.position[2]];
+            }
+            const sx = Math.round(ridgeWorld[0] * 20) / 20;
+            const sz = Math.round(ridgeWorld[2] * 20) / 20;
+            const prev = lastSnapRef.current;
+            if (event.nativeEvent?.shiftKey !== true && (!prev || prev[0] !== sx || prev[1] !== sz)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnapRef.current = [sx, sz];
+            }
+            setPreviewYaw((event.node.rotation ?? 0) + (hit.segment.rotation ?? 0) + snap.rotation);
+            setPreviewPos(worldToBuildingLocal(ridgeWorld[0], ridgeWorld[1], ridgeWorld[2]));
+            publishRoofSurfacePlacementGuides({
+                roof: event.node,
+                segment: hit.segment,
+                center: [
+                    snap.localX,
+                    getRoofTopSurfaceY(snap.localX, snap.localZ, hit.segment),
+                    snap.localZ,
+                ],
+                footprint: roofSurfaceFootprintFromNode(previewNode),
+                mode: 'linear-edge',
+            });
+            event.stopPropagation();
+        };
+        const onClick = (event) => {
+            const hit = resolveRoofSegmentHit(event.node, event.position[0], event.position[1], event.position[2]);
+            if (!hit)
+                return;
+            const snap = resolveRidgeSnap(hit.segment, hit.localX, hit.localZ);
+            if (!snap)
+                return;
+            const state = useScene.getState();
+            const vent = RidgeVentNode.parse({
+                ...ridgeVentDefinition.defaults(),
+                name: 'Ridge Vent',
+                roofSegmentId: hit.segment.id,
+                position: [snap.localX, 0, snap.localZ],
+                rotation: snap.rotation,
+            });
+            state.createNode(vent, hit.segment.id);
+            state.dirtyNodes.add(hit.segment.id);
+            setSelection({ selectedIds: [vent.id] });
+            triggerSFX('sfx:item-place');
+            clearRoofSurfacePlacementGuides();
+            event.stopPropagation();
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onClick);
+        return () => {
+            emitter.off('roof:move', updatePreview);
+            emitter.off('roof:enter', updatePreview);
+            emitter.off('roof:click', onClick);
+            clearRoofSurfacePlacementGuides();
+        };
+    }, [activeBuildingId, setSelection, previewNode]);
+    return (_jsxs(_Fragment, { children: [_jsx(RoofAttachmentFallbackPreview, { activeBuildingId: activeBuildingId, ghost: _jsx(RidgeVentPreview, { node: previewNode, invalid: true }), isValidRoofTarget: (event) => {
+                    const hit = resolveRoofSegmentHit(event.node, event.position[0], event.position[1], event.position[2]);
+                    return !!hit && !!resolveRidgeSnap(hit.segment, hit.localX, hit.localZ);
+                }, onInvalidTarget: () => {
+                    setPreviewPos(null);
+                    clearRoofSurfacePlacementGuides();
+                } }), activeBuildingId && previewPos && (_jsx("group", { position: previewPos, children: _jsx("group", { "rotation-y": previewYaw, children: _jsx(RidgeVentPreview, { node: previewNode }) }) }))] }));
+};
+export default RidgeVentTool;

package/dist/roof/definition.d.ts

@@ -0,0 +1,16 @@
+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`).
+ */
+export declare const roofDefinition: NodeDefinition<typeof RoofNode>;
+//# sourceMappingURL=definition.d.ts.map

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

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

package/dist/roof/definition.js

@@ -0,0 +1,170 @@
+import { RoofNode as RoofNodeSchema, } from '@pascal-app/core';
+import { buildRoofFloorplan } from './floorplan';
+import { roofParametrics } from './parametrics';
+import { RoofNode } from './schema';
+const MOVE_FRONT_OFFSET = 0.35;
+const MIN_ROOF_FOOTPRINT = 1;
+function getRoofFootprintBounds(node, sceneApi) {
+    let bounds = null;
+    for (const childId of node.children ?? []) {
+        const segment = sceneApi.get(childId);
+        if (segment?.type !== 'roof-segment')
+            continue;
+        const halfWidth = Math.max(segment.width, MIN_ROOF_FOOTPRINT) / 2;
+        const halfDepth = Math.max(segment.depth, MIN_ROOF_FOOTPRINT) / 2;
+        const cos = Math.cos(segment.rotation ?? 0);
+        const sin = Math.sin(segment.rotation ?? 0);
+        const corners = [
+            [-halfWidth, -halfDepth],
+            [halfWidth, -halfDepth],
+            [halfWidth, halfDepth],
+            [-halfWidth, halfDepth],
+        ];
+        for (const [x, z] of corners) {
+            const localX = segment.position[0] + x * cos + z * sin;
+            const localZ = segment.position[2] - x * sin + z * cos;
+            bounds =
+                bounds === null
+                    ? { maxX: localX, maxZ: localZ, minX: localX, minZ: localZ }
+                    : {
+                        maxX: Math.max(bounds.maxX, localX),
+                        maxZ: Math.max(bounds.maxZ, localZ),
+                        minX: Math.min(bounds.minX, localX),
+                        minZ: Math.min(bounds.minZ, localZ),
+                    };
+        }
+    }
+    return bounds ?? { maxX: 0.5, maxZ: 0.5, minX: -0.5, minZ: -0.5 };
+}
+function roofMoveHandle() {
+    return {
+        kind: 'translate',
+        placement: {
+            position: (node, sceneApi) => {
+                const bounds = getRoofFootprintBounds(node, sceneApi);
+                return [(bounds.minX + bounds.maxX) / 2, 0.02, bounds.maxZ + MOVE_FRONT_OFFSET];
+            },
+        },
+        apply: (_node, position) => ({ position: [position[0], position[1], position[2]] }),
+        snapExtents: (node, sceneApi) => {
+            const bounds = getRoofFootprintBounds(node, sceneApi);
+            const width = Math.max(bounds.maxX - bounds.minX, MIN_ROOF_FOOTPRINT);
+            const depth = Math.max(bounds.maxZ - bounds.minZ, MIN_ROOF_FOOTPRINT);
+            const swap = Math.abs(Math.sin(node.rotation ?? 0)) > 0.9;
+            return [swap ? depth : width, swap ? width : depth];
+        },
+    };
+}
+const roofHandles = [roofMoveHandle()];
+/**
+ * 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`).
+ */
+export const roofDefinition = {
+    kind: 'roof',
+    snapProfile: 'structural',
+    // 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,
+    schema: RoofNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = RoofNodeSchema.parse({ id: 'roof_default', type: 'roof' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Contribute a plan AABB to the alignment-guide candidate pool so a roof
+        // (and any moving sibling) snaps against the roof's outer silhouette.
+        // Roof has no centred-box footprint — it's the union of its
+        // `roof-segment` children — so we hand the bridge a resolved `aabb`
+        // directly. The roof moves by its origin via `move-roof-tool`, so it
+        // only ever contributes static candidates; the relocatable-box path
+        // never needs to apply to roofs.
+        alignmentFootprint: (node, nodes) => {
+            const roof = node;
+            if (!nodes)
+                return null;
+            const cos = Math.cos(roof.rotation ?? 0);
+            const sin = Math.sin(roof.rotation ?? 0);
+            let minX = Number.POSITIVE_INFINITY;
+            let minZ = Number.POSITIVE_INFINITY;
+            let maxX = Number.NEGATIVE_INFINITY;
+            let maxZ = Number.NEGATIVE_INFINITY;
+            let any = false;
+            for (const childId of roof.children ?? []) {
+                const segment = nodes[childId];
+                if (segment?.type !== 'roof-segment')
+                    continue;
+                const halfWidth = Math.max(segment.width, MIN_ROOF_FOOTPRINT) / 2;
+                const halfDepth = Math.max(segment.depth, MIN_ROOF_FOOTPRINT) / 2;
+                const sCos = Math.cos(segment.rotation ?? 0);
+                const sSin = Math.sin(segment.rotation ?? 0);
+                for (const [cx, cz] of [
+                    [-halfWidth, -halfDepth],
+                    [halfWidth, -halfDepth],
+                    [halfWidth, halfDepth],
+                    [-halfWidth, halfDepth],
+                ]) {
+                    // Segment corner → roof-local.
+                    const rx = segment.position[0] + cx * sCos + cz * sSin;
+                    const rz = segment.position[2] - cx * sSin + cz * sCos;
+                    // Roof-local → world (apply roof rotation, then position).
+                    const wx = roof.position[0] + rx * cos + rz * sin;
+                    const wz = roof.position[2] - rx * sin + rz * cos;
+                    if (wx < minX)
+                        minX = wx;
+                    if (wx > maxX)
+                        maxX = wx;
+                    if (wz < minZ)
+                        minZ = wz;
+                    if (wz > maxZ)
+                        maxZ = wz;
+                    any = true;
+                }
+            }
+            return any ? { shape: 'aabb', minX, minZ, maxX, maxZ } : null;
+        },
+    },
+    // Bespoke free-floating move (drag-to-place with R/T rotation and
+    // wall/fence snapping). Routes through `MoveTool`'s registry-affordance
+    // lookup — no hardcoded dispatcher arm. Shared with roof-segment / stair
+    // / stair-segment via `shared/move-roof-tool`.
+    affordanceTools: {
+        move: () => import('../shared/move-roof-tool'),
+    },
+    parametrics: roofParametrics,
+    handles: roofHandles,
+    floorplan: buildRoofFloorplan,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    system: {
+        module: () => import('./system'),
+        priority: 3,
+    },
+    presentation: {
+        label: 'Roof',
+        description: 'A pitched / hip / gable roof composed of one or more segments.',
+        icon: { kind: 'url', src: '/icons/roof.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 100,
+    },
+    mcp: {
+        description: 'A roof composed of segmented planes (gable / hip / shed).',
+    },
+};

package/dist/roof/floorplan.d.ts

@@ -0,0 +1,21 @@
+import type { FloorplanGeometry, GeometryContext, 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.
+ *
+ * Composition uses the floor plan's negated-rotation convention
+ * (segment-local → roof-local → plan). `unionPolygons` returns one ring per
+ * disjoint group, so non-touching segments each keep their own outline. The
+ * group is decorative (`pointerEvents: 'none'`) — clicks fall through to the
+ * segment hit-targets.
+ */
+export declare function buildRoofFloorplan(node: RoofNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

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