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

package/dist/roof/floorplan.js

@@ -1,63 +1,20 @@
-import { unionPolygons } from '@pascal-app/viewer';
-import { getRoofSegmentPlanLinework } from '../roof-segment/floorplan';
-function signedArea(ring) {
-    let a = 0;
-    const n = ring.length;
-    for (let i = 0; i < n; i++) {
-        const p = ring[i];
-        const q = ring[(i + 1) % n];
-        a += p[0] * q[1] - q[0] * p[1];
-    }
-    return a / 2;
-}
-/** Distance `t >= 0` from `V` along unit dir `(dx,dz)` to where the ray first
- *  meets segment `A→B`, or null. (Used to terminate valleys at ridges.) */
-function rayHitT(vx, vz, dx, dz, ax, az, bx, bz) {
-    const ex = bx - ax;
-    const ez = bz - az;
-    const denom = dx * ez - dz * ex;
-    if (Math.abs(denom) < 1e-9)
-        return null;
-    const wx = ax - vx;
-    const wz = az - vz;
-    const t = (wx * ez - wz * ex) / denom;
-    const s = (wx * dz - wz * dx) / denom;
-    if (t < 0)
-        return null;
-    if (s < -1e-6 || s > 1 + 1e-6)
-        return null;
-    return t;
-}
-function pointInPolygon(px, pz, poly) {
-    let inside = false;
-    for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
-        const pi = poly[i];
-        const pj = poly[j];
-        if (pi[1] > pz !== pj[1] > pz &&
-            px < ((pj[0] - pi[0]) * (pz - pi[1])) / (pj[1] - pi[1]) + pi[0]) {
-            inside = !inside;
-        }
-    }
-    return inside;
-}
-/** Parametric `t` in (0,1) along `p1→p2` where it crosses segment `a→b`, else null. */
-function segCrossT(p1, p2, a, b) {
-    const rx = p2[0] - p1[0];
-    const rz = p2[1] - p1[1];
-    const ex = b[0] - a[0];
-    const ez = b[1] - a[1];
-    const denom = rx * ez - rz * ex;
-    if (Math.abs(denom) < 1e-12)
-        return null;
-    const wx = a[0] - p1[0];
-    const wz = a[1] - p1[1];
-    const t = (wx * ez - wz * ex) / denom;
-    const s = (wx * rz - wz * rx) / denom;
-    if (t <= 1e-4 || t >= 1 - 1e-9)
-        return null;
-    if (s < -1e-6 || s > 1 + 1e-6)
-        return null;
-    return t;
+import { roofPlanOverlapEntryOwns, subtractPolygonsFromPolygon, unionPolygons, } from '@pascal-app/core';
+import { getConicalRoofPlanFootprint, getRoofSegmentPlanLinework } from '../roof-segment/floorplan';
+function overlapEntry(entry, ctx) {
+    const supportSegment = entry.roof.support?.kind === 'roof'
+        ? ctx.resolve(entry.roof.support.roofSegmentId)
+        : undefined;
+    return {
+        roofId: String(entry.roof.id),
+        segmentId: String(entry.segment.id),
+        supportRoofId: supportSegment?.type === 'roof-segment' && supportSegment.parentId
+            ? String(supportSegment.parentId)
+            : undefined,
+        supportRoofSegmentId: entry.roof.support?.kind === 'roof' ? String(entry.roof.support.roofSegmentId) : undefined,
+        roofType: entry.segment.roofType,
+        width: entry.segment.width,
+        depth: entry.segment.depth,
+    };
 }
 /** A segment's footprint + ridge/hip/break/slope linework, in world plan coords. */
 function buildSegPlan(roof, seg) {
@@ -79,8 +36,11 @@ function buildSegPlan(roof, seg) {
         tp(s[0][0], s[0][1]),
         tp(s[1][0], s[1][1]),
     ];
+    const footprint = seg.roofType === 'conical'
+        ? getConicalRoofPlanFootprint(seg).map(([x, z]) => tp(x, z))
+        : [tp(-hw, -hd), tp(hw, -hd), tp(hw, hd), tp(-hw, hd)];
     return {
-        footprint: [tp(-hw, -hd), tp(hw, -hd), tp(hw, hd), tp(-hw, hd)],
+        footprint,
         ridges: lw.ridges.map(mapSeg),
         hips: lw.hips.map(mapSeg),
         breaks: lw.breaks.map(mapSeg),
@@ -92,17 +52,69 @@ function buildSegPlan(roof, seg) {
             : null,
     };
 }
+function pointInPolygon(point, polygon) {
+    let inside = false;
+    for (let index = 0, previous = polygon.length - 1; index < polygon.length; previous = index++) {
+        const [x, y] = polygon[index];
+        const [px, py] = polygon[previous];
+        if (y > point[1] === py > point[1])
+            continue;
+        const crossingX = ((px - x) * (point[1] - y)) / (py - y) + x;
+        if (point[0] < crossingX)
+            inside = !inside;
+    }
+    return inside;
+}
+function segmentIntersectionParameter(line, edge) {
+    const lineX = line[1][0] - line[0][0];
+    const lineY = line[1][1] - line[0][1];
+    const edgeX = edge[1][0] - edge[0][0];
+    const edgeY = edge[1][1] - edge[0][1];
+    const determinant = lineX * edgeY - lineY * edgeX;
+    if (Math.abs(determinant) <= 1e-9)
+        return null;
+    const offsetX = edge[0][0] - line[0][0];
+    const offsetY = edge[0][1] - line[0][1];
+    const lineT = (offsetX * edgeY - offsetY * edgeX) / determinant;
+    const edgeT = (offsetX * lineY - offsetY * lineX) / determinant;
+    return lineT > 1e-9 && lineT < 1 - 1e-9 && edgeT >= -1e-9 && edgeT <= 1 + 1e-9 ? lineT : null;
+}
+function clipLineByCutters(line, cutters) {
+    const parameters = [0, 1];
+    for (const cutter of cutters) {
+        for (let index = 0; index < cutter.length; index++) {
+            const parameter = segmentIntersectionParameter(line, [
+                cutter[index],
+                cutter[(index + 1) % cutter.length],
+            ]);
+            if (parameter !== null)
+                parameters.push(parameter);
+        }
+    }
+    parameters.sort((a, b) => a - b);
+    const dx = line[1][0] - line[0][0];
+    const dy = line[1][1] - line[0][1];
+    const result = [];
+    for (let index = 0; index < parameters.length - 1; index++) {
+        const startT = parameters[index];
+        const endT = parameters[index + 1];
+        if (endT - startT <= 1e-9)
+            continue;
+        const midT = (startT + endT) / 2;
+        const midpoint = [line[0][0] + dx * midT, line[0][1] + dy * midT];
+        if (cutters.some((cutter) => pointInPolygon(midpoint, cutter)))
+            continue;
+        result.push([
+            [line[0][0] + dx * startT, line[0][1] + dy * startT],
+            [line[0][0] + dx * endT, line[0][1] + dy * endT],
+        ]);
+    }
+    return result;
+}
 /**
  * Roof-level floor-plan builder. Draws the whole merged-roof plan: the
- * unioned silhouette, the valley diagonals at concave junctions, and every
- * segment's ridge/hip/break linework — clipped so a line stops at the valley
- * where its segment overlaps a neighbour, instead of running on at the
- * segment's full length into the cut-away part.
- *
- * Drawing all the linework here (rather than per-segment) is what lets the
- * clip work: the valleys and the neighbouring footprints are all in hand, so
- * each line can be trimmed to the actual merged geometry. The segment
- * builder keeps only its hit-target / selection chrome.
+ * unioned silhouette and every segment's ridge/hip/break linework. The
+ * segment builder keeps only its hit-target / selection chrome.
  *
  * Composition uses the floor plan's negated-rotation convention
  * (segment-local → roof-local → plan). `unionPolygons` returns one ring per
@@ -114,53 +126,41 @@ export function buildRoofFloorplan(node, ctx) {
     const segments = ctx.children.filter((c) => c.type === 'roof-segment');
     if (segments.length === 0)
         return null;
-    const plans = segments.map((s) => buildSegPlan(node, s));
-    const rings = unionPolygons(plans.map((p) => p.footprint));
-    if (rings.length === 0)
-        return null;
-    // Valleys at concave (reflex) corners of the merged outline. Each runs
-    // along the interior angle bisector and terminates at the nearest segment
-    // ridge — the diagonal where two merged slopes meet.
-    const allRidges = plans.flatMap((p) => p.ridges);
-    const valleys = [];
-    for (const ring of rings) {
-        const n = ring.length;
-        if (n < 3)
+    const entries = segments.map((segment) => ({
+        roof: node,
+        segment,
+        plan: buildSegPlan(node, segment),
+    }));
+    for (const sibling of ctx.siblings) {
+        if (sibling.type !== 'roof')
             continue;
-        const orient = signedArea(ring) > 0 ? 1 : -1;
-        for (let i = 0; i < n; i++) {
-            const prev = ring[(i - 1 + n) % n];
-            const V = ring[i];
-            const next = ring[(i + 1) % n];
-            const ax = prev[0] - V[0];
-            const az = prev[1] - V[1];
-            const bx = next[0] - V[0];
-            const bz = next[1] - V[1];
-            if ((ax * bz - az * bx) * orient <= 0)
-                continue; // not reflex
-            const la = Math.hypot(ax, az) || 1;
-            const lb = Math.hypot(bx, bz) || 1;
-            let dx = -(ax / la + bx / lb);
-            let dz = -(az / la + bz / lb);
-            const dl = Math.hypot(dx, dz);
-            if (dl < 1e-6)
+        for (const childId of sibling.children ?? []) {
+            const segment = ctx.resolve(childId);
+            if (segment?.type !== 'roof-segment')
                 continue;
-            dx /= dl;
-            dz /= dl;
-            let bestT = Number.POSITIVE_INFINITY;
-            for (const [A, B] of allRidges) {
-                const t = rayHitT(V[0], V[1], dx, dz, A[0], A[1], B[0], B[1]);
-                if (t !== null && t > 1e-4 && t < bestT)
-                    bestT = t;
-            }
-            if (!Number.isFinite(bestT))
-                continue;
-            valleys.push([
-                [V[0], V[1]],
-                [V[0] + dx * bestT, V[1] + dz * bestT],
-            ]);
+            entries.push({ roof: sibling, segment, plan: buildSegPlan(sibling, segment) });
         }
     }
+    const currentEntries = entries.filter((entry) => entry.roof.id === node.id);
+    const visiblePlans = currentEntries.map((entry) => {
+        const cutters = entries
+            .filter((candidate) => {
+            if (candidate.segment.id === entry.segment.id)
+                return false;
+            if (candidate.segment.roofType === 'shed')
+                return false;
+            return roofPlanOverlapEntryOwns(overlapEntry(candidate, ctx), overlapEntry(entry, ctx));
+        })
+            .map((candidate) => candidate.plan.footprint);
+        return {
+            plan: entry.plan,
+            cutters,
+            footprints: subtractPolygonsFromPolygon(entry.plan.footprint, cutters),
+        };
+    });
+    const rings = unionPolygons(visiblePlans.flatMap(({ footprints }) => footprints));
+    if (rings.length === 0)
+        return null;
     const view = ctx.viewState;
     const palette = view?.palette;
     const showSelectedChrome = (view?.selected ?? false) || (view?.highlighted ?? false);
@@ -196,68 +196,42 @@ export function buildRoofFloorplan(node, ctx) {
             pointerEvents: 'none',
         });
     }
-    // Valley diagonals.
-    for (const v of valleys)
-        pushLine(v[0], v[1], hipWidth);
-    // Per-segment ridge / hip / break linework, clipped to the merged geometry:
-    // an endpoint that overshoots into another segment is pulled back to the
-    // valley it crosses (the junction), so a ridge stops at the diagonal.
-    const footprints = plans.map((p) => p.footprint);
-    const clipEnd = (pt, other, ownIndex) => {
-        let inOther = false;
-        for (let i = 0; i < footprints.length; i++) {
-            if (i === ownIndex)
-                continue;
-            if (pointInPolygon(pt[0], pt[1], footprints[i])) {
-                inOther = true;
-                break;
+    for (const { plan, cutters } of visiblePlans) {
+        for (const line of plan.breaks) {
+            for (const visible of clipLineByCutters(line, cutters)) {
+                pushLine(visible[0], visible[1], hipWidth);
             }
         }
-        if (!inOther)
-            return pt;
-        let bestT = Number.POSITIVE_INFINITY; // nearest valley crossing to the overshoot
-        for (const v of valleys) {
-            const t = segCrossT(pt, other, v[0], v[1]);
-            if (t !== null && t < bestT)
-                bestT = t;
+        for (const line of plan.hips) {
+            for (const visible of clipLineByCutters(line, cutters)) {
+                pushLine(visible[0], visible[1], hipWidth);
+            }
         }
-        if (!Number.isFinite(bestT))
-            return pt; // overshoots but no valley to stop at
-        return [pt[0] + (other[0] - pt[0]) * bestT, pt[1] + (other[1] - pt[1]) * bestT];
-    };
-    const clipPush = (line, width, ownIndex) => {
-        const a = clipEnd(line[0], line[1], ownIndex);
-        const b = clipEnd(line[1], a, ownIndex);
-        const dx = a[0] - b[0];
-        const dz = a[1] - b[1];
-        if (dx * dx + dz * dz < 1e-8)
-            return;
-        pushLine(a, b, width);
-    };
-    plans.forEach((p, idx) => {
-        for (const s of p.breaks)
-            clipPush(s, hipWidth, idx);
-        for (const s of p.hips)
-            clipPush(s, hipWidth, idx);
-        for (const s of p.ridges)
-            clipPush(s, ridgeWidth, idx);
-        // Shed downslope arrow (no overshoot to clip).
-        if (p.slope) {
-            const { tail, head } = p.slope;
-            const dx = head[0] - tail[0];
-            const dz = head[1] - tail[1];
+        for (const line of plan.ridges) {
+            for (const visible of clipLineByCutters(line, cutters)) {
+                pushLine(visible[0], visible[1], ridgeWidth);
+            }
+        }
+        if (plan.slope) {
+            const { tail, head } = plan.slope;
+            const visibleSlope = clipLineByCutters([tail, head], cutters).at(-1);
+            if (!visibleSlope)
+                continue;
+            const [visibleTail, visibleHead] = visibleSlope;
+            const dx = visibleHead[0] - visibleTail[0];
+            const dz = visibleHead[1] - visibleTail[1];
             const len = Math.hypot(dx, dz) || 1;
             const ux = dx / len;
             const uz = dz / len;
             const headLen = Math.min(0.22, len * 0.4);
             const wing = headLen * 0.6;
-            pushLine(tail, head, hipWidth);
+            pushLine(visibleTail, visibleHead, hipWidth);
             children.push({
                 kind: 'polyline',
                 points: [
-                    [head[0] - headLen * ux - wing * uz, head[1] - headLen * uz + wing * ux],
-                    [head[0], head[1]],
-                    [head[0] - headLen * ux + wing * uz, head[1] - headLen * uz - wing * ux],
+                    [visibleHead[0] - headLen * ux - wing * uz, visibleHead[1] - headLen * uz + wing * ux],
+                    [visibleHead[0], visibleHead[1]],
+                    [visibleHead[0] - headLen * ux + wing * uz, visibleHead[1] - headLen * uz - wing * ux],
                 ],
                 stroke: ink,
                 strokeWidth: hipWidth,
@@ -266,6 +240,6 @@ export function buildRoofFloorplan(node, ctx) {
                 pointerEvents: 'none',
             });
         }
-    });
+    }
     return children.length > 0 ? { kind: 'group', children } : null;
 }

package/dist/roof/index.d.ts

@@ -1,3 +1,4 @@
 export { type RoofSegmentHit, resolveRoofSegmentHit } from '../shared/roof-segment-hit';
 export { roofDefinition } from './definition';
+export { default as useRoofFootprintSource, type RoofFootprintSourceChoice, } from './roof-footprint-source';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/roof/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/roof/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EACL,OAAO,IAAI,sBAAsB,EACjC,KAAK,yBAAyB,GAC/B,MAAM,yBAAyB,CAAA"}

package/dist/roof/index.js

@@ -1,2 +1,3 @@
 export { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
 export { roofDefinition } from './definition';
+export { default as useRoofFootprintSource, } from './roof-footprint-source';

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/roof/panel.tsx"],"names":[],"mappings":"AAmCA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAmgBhC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/roof/panel.tsx"],"names":[],"mappings":"AAiCA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA0gBhC"}

package/dist/roof/panel.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { createDefaultRidgeVentsForSegment, RoofSegmentNode as RoofSegmentNodeSchema, useScene, } from '@pascal-app/core';
+import { useScene, } from '@pascal-app/core';
 import { ActionButton, ActionGroup, duplicateRoofSubtree, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, Move, Plus, Trash2 } from 'lucide-react';
@@ -11,7 +11,6 @@ export default function RoofPanel() {
     const selectedId = useViewer((s) => s.selection.selectedIds[0]);
     const setSelection = useViewer((s) => s.setSelection);
     const updateNode = useScene((s) => s.updateNode);
-    const createNodes = useScene((s) => s.createNodes);
     const setMovingNode = useEditor((s) => s.setMovingNode);
     const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
     // Shallow selector — only re-renders when the segment list content changes.
@@ -114,23 +113,12 @@ export default function RoofPanel() {
     const handleAddSegment = useCallback(() => {
         if (!node)
             return;
-        const segment = RoofSegmentNodeSchema.parse({
-            width: 6,
-            depth: 6,
-            wallHeight: 0.5,
-            pitch: 40,
-            roofType: 'gable',
-            position: [2, 0, 2],
-        });
-        const ridgeVents = createDefaultRidgeVentsForSegment(segment);
-        createNodes([
-            { node: segment, parentId: node.id },
-            ...ridgeVents.map((ridgeVent) => ({
-                node: ridgeVent,
-                parentId: segment.id,
-            })),
-        ]);
-    }, [node, createNodes]);
+        triggerSFX('sfx:item-pick');
+        const editor = useEditor.getState();
+        editor.setTool('roof');
+        if (editor.mode !== 'build')
+            editor.setMode('build');
+    }, [node]);
     const handleSelectSegment = useCallback((segmentId) => {
         setSelection({ selectedIds: [segmentId] });
     }, [setSelection]);
@@ -177,15 +165,26 @@ export default function RoofPanel() {
     }, []);
     if (!(node && node.type === 'roof' && selectedId))
         return null;
-    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onClose: handleClose, title: node.name || 'Roof', width: 300, children: [_jsxs(PanelSection, { title: "Segments", children: [_jsx("div", { className: "flex flex-col gap-1", children: segments.map((seg, i) => (_jsxs("button", { className: "flex items-center justify-between rounded-lg border border-border/50 bg-[#2C2C2E] px-3 py-2 text-foreground text-sm transition-colors hover:bg-[#3e3e3e]", onClick: () => handleSelectSegment(seg.id), type: "button", children: [_jsx("span", { className: "truncate", children: seg.name || `Segment ${i + 1}` }), _jsx("span", { className: "text-muted-foreground text-xs capitalize", children: seg.roofType })] }, seg.id))) }), _jsx(ActionGroup, { children: _jsx(ActionButton, { icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: "Add Segment", onClick: handleAddSegment }) })] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: 50, min: -50, onChange: (v) => {
+    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onClose: handleClose, title: node.name || 'Roof', width: 300, children: [_jsxs(PanelSection, { title: "Segments", children: [_jsx("div", { className: "flex flex-col gap-1", children: segments.map((seg, i) => (_jsxs("button", { className: "flex items-center justify-between rounded-lg border border-border/50 bg-[#2C2C2E] px-3 py-2 text-foreground text-sm transition-colors hover:bg-[#3e3e3e]", onClick: () => handleSelectSegment(seg.id), type: "button", children: [_jsx("span", { className: "truncate", children: seg.name || `Segment ${i + 1}` }), _jsx("span", { className: "text-muted-foreground text-xs capitalize", children: seg.roofType })] }, seg.id))) }), _jsx(ActionGroup, { children: _jsx(ActionButton, { icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: "Draw Segment", onClick: handleAddSegment }) })] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", onChange: (v) => {
                             const pos = [...node.position];
                             pos[0] = v;
                             handleUpdate({ position: pos });
-                        }, precision: 2, step: 0.05, unit: "m", value: Math.round(node.position[0] * 100) / 100 }), _jsx(SliderControl, { label: "Y", max: 50, min: -50, onChange: (v) => {
+                        }, precision: 2, step: 0.05, unit: "m", value: Math.round(node.position[0] * 100) / 100 }), node.support?.kind !== 'roof' && (_jsx(SegmentedControl, { onChange: (mode) => handleUpdate({ support: { kind: mode === 'walls' ? 'walls' : 'level' } }), options: [
+                            { label: 'Follows walls', value: 'walls' },
+                            { label: 'Custom', value: 'custom' },
+                        ], value: node.support?.kind === 'walls' ? 'walls' : 'custom' })), node.support?.kind === 'walls' ? (_jsxs("div", { className: "px-1 text-[11px] text-muted-foreground", children: ["Currently ", Math.round(node.position[1] * 100) / 100, " m"] })) : (_jsx(SliderControl, { label: "Y", onChange: (v) => {
                             const pos = [...node.position];
                             pos[1] = v;
-                            handleUpdate({ position: pos });
-                        }, precision: 2, step: 0.05, unit: "m", value: Math.round(node.position[1] * 100) / 100 }), _jsx(SliderControl, { label: "Z", max: 50, min: -50, onChange: (v) => {
+                            const current = useScene.getState().nodes[node.id];
+                            handleUpdate({
+                                position: pos,
+                                ...(current?.type === 'roof' &&
+                                    current.support?.kind === 'walls' &&
+                                    Math.abs(v - current.position[1]) > 1e-4
+                                    ? { support: { kind: 'level' } }
+                                    : {}),
+                            });
+                        }, precision: 2, step: 0.05, unit: "m", value: Math.round(node.position[1] * 100) / 100 })), _jsx(SliderControl, { label: "Z", onChange: (v) => {
                             const pos = [...node.position];
                             pos[2] = v;
                             handleUpdate({ position: pos });

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/roof/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAQzB,eAAO,MAAM,YAAY,GAAI,mBAAmB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAmHjE,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/roof/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAQzB,eAAO,MAAM,YAAY,GAAI,mBAAmB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAkHjE,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/roof/roof-footprint-source.d.ts

@@ -0,0 +1,16 @@
+export type RoofFootprintSourceChoice = 'draw' | 'room';
+type RoofFootprintSourceState = {
+    source: RoofFootprintSourceChoice;
+    setSource: (source: RoofFootprintSourceChoice) => void;
+};
+/**
+ * How the user wants the next roof footprint made — draw two corners, or pick
+ * a detected room ('walls' is conical-only and forced by
+ * `parseRoofFootprintSource`, so it never lives here). Ephemeral UI state
+ * owned by the kind, like `roof-placement-mode`: deliberately OUTSIDE
+ * `toolDefaults.roof`, which preset seeding nulls on every activation and the
+ * tool clears on unmount — both used to wipe the user's choice.
+ */
+declare const useRoofFootprintSource: import("zustand").UseBoundStore<import("zustand").StoreApi<RoofFootprintSourceState>>;
+export default useRoofFootprintSource;
+//# sourceMappingURL=roof-footprint-source.d.ts.map

package/dist/roof/roof-footprint-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-footprint-source.d.ts","sourceRoot":"","sources":["../../src/roof/roof-footprint-source.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,yBAAyB,GAAG,MAAM,GAAG,MAAM,CAAA;AAEvD,KAAK,wBAAwB,GAAG;IAC9B,MAAM,EAAE,yBAAyB,CAAA;IACjC,SAAS,EAAE,CAAC,MAAM,EAAE,yBAAyB,KAAK,IAAI,CAAA;CACvD,CAAA;AAED;;;;;;;GAOG;AACH,QAAA,MAAM,sBAAsB,uFAGzB,CAAA;AAEH,eAAe,sBAAsB,CAAA"}

package/dist/roof/roof-footprint-source.js

@@ -0,0 +1,14 @@
+import { create } from 'zustand';
+/**
+ * How the user wants the next roof footprint made — draw two corners, or pick
+ * a detected room ('walls' is conical-only and forced by
+ * `parseRoofFootprintSource`, so it never lives here). Ephemeral UI state
+ * owned by the kind, like `roof-placement-mode`: deliberately OUTSIDE
+ * `toolDefaults.roof`, which preset seeding nulls on every activation and the
+ * tool clears on unmount — both used to wipe the user's choice.
+ */
+const useRoofFootprintSource = create((set) => ({
+    source: 'draw',
+    setSource: (source) => set({ source }),
+}));
+export default useRoofFootprintSource;

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

@@ -0,0 +1,25 @@
+import { type AnyNode, type LevelNode, type RoofFootprintTarget, type RoofType, type WallNode } from '@pascal-app/core';
+export type RoofFootprintSource = 'room' | 'walls' | 'draw';
+export declare function isStandardRoofWallEligible(wall: WallNode): boolean;
+export declare function isConicalRoofWallEligible(targetLevelId: LevelNode['id'], wall: WallNode, nodes: Readonly<Record<string, AnyNode>>): boolean;
+export declare function parseRoofFootprintSource(value: unknown, roofType: RoofType): RoofFootprintSource;
+export declare function subscribeToConicalRoofWallClicks(options: {
+    footprintSource: RoofFootprintSource;
+    currentLevelId: LevelNode['id'] | null;
+    getNodes: () => Readonly<Record<string, AnyNode>>;
+    onPreview?: (wall: WallNode | null) => void;
+    onSelect: (wall: WallNode) => void;
+    roofType: RoofType;
+}): () => void;
+export declare function resolveRoofFootprintElevation(targetLevelId: LevelNode['id'], target: RoofFootprintTarget, nodes: Readonly<Record<string, AnyNode>>): number;
+export declare function resolveRoofFootprintWorldElevation(targetLevelId: LevelNode['id'], target: RoofFootprintTarget, nodes: Readonly<Record<string, AnyNode>>): number;
+/**
+ * World/building-local Y for a wall-top preview rendered outside a level node.
+ *
+ * Roof nodes are parented to a level, so their stored position is relative to
+ * that level's floor. The conical wall hover ghost is rendered directly in the
+ * building group instead, and therefore needs the active level's world base
+ * added back after resolving the level-relative placement.
+ */
+export declare function resolveRoofWallTopWorldElevation(targetLevelId: LevelNode['id'], wall: WallNode, nodes: Readonly<Record<string, AnyNode>>, elevations?: Map<string, import("@pascal-app/core").LevelElevation>): number;
+//# sourceMappingURL=roof-footprint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"roof-footprint.d.ts","sourceRoot":"","sources":["../../src/roof/roof-footprint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAKZ,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,QAAQ,EAIb,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAA;AAI3D,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAKlE;AAED,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,EAC9B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,OAAO,CAMT;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,GAAG,mBAAmB,CAGhG;AAED,wBAAgB,gCAAgC,CAAC,OAAO,EAAE;IACxD,eAAe,EAAE,mBAAmB,CAAA;IACpC,cAAc,EAAE,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACtC,QAAQ,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACjD,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAA;IAC3C,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAA;IAClC,QAAQ,EAAE,QAAQ,CAAA;CACnB,GAAG,MAAM,IAAI,CA0Cb;AAED,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,EAC9B,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,CAUR;AAED,wBAAgB,kCAAkC,CAChD,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,EAC9B,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,CAOR;AAED;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAC9C,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,EAC9B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,yDAAuD,GAChE,MAAM,CAKR"}

package/dist/roof/roof-footprint.js

@@ -0,0 +1,94 @@
+import { emitter, getLevelBelow, getLevelElevations, isCurvedWall, resolveLevelId, resolveRoofWallTopElevation, } from '@pascal-app/core';
+const ROOF_AXIS_ALIGNMENT_EPSILON = 1e-4;
+export function isStandardRoofWallEligible(wall) {
+    if (isCurvedWall(wall))
+        return false;
+    const deltaX = Math.abs(wall.end[0] - wall.start[0]);
+    const deltaZ = Math.abs(wall.end[1] - wall.start[1]);
+    return deltaX <= ROOF_AXIS_ALIGNMENT_EPSILON || deltaZ <= ROOF_AXIS_ALIGNMENT_EPSILON;
+}
+export function isConicalRoofWallEligible(targetLevelId, wall, nodes) {
+    const completeNodes = nodes;
+    const sourceLevelId = resolveLevelId(wall, completeNodes);
+    if (!sourceLevelId)
+        return false;
+    if (sourceLevelId === targetLevelId)
+        return true;
+    return getLevelBelow(targetLevelId, completeNodes)?.id === sourceLevelId;
+}
+export function parseRoofFootprintSource(value, roofType) {
+    if (roofType === 'conical')
+        return 'walls';
+    return value === 'room' ? 'room' : 'draw';
+}
+export function subscribeToConicalRoofWallClicks(options) {
+    if (!(options.roofType === 'conical' && options.footprintSource === 'walls'))
+        return () => { };
+    let previewedWallId = null;
+    const onWallHover = (event) => {
+        const wall = isCurvedWall(event.node) &&
+            options.currentLevelId &&
+            isConicalRoofWallEligible(options.currentLevelId, event.node, options.getNodes())
+            ? event.node
+            : null;
+        const nextId = wall?.id ?? null;
+        if (nextId === previewedWallId)
+            return;
+        previewedWallId = nextId;
+        options.onPreview?.(wall);
+    };
+    const onWallLeave = (event) => {
+        if (event.node.id !== previewedWallId)
+            return;
+        previewedWallId = null;
+        options.onPreview?.(null);
+    };
+    const onWallClick = (event) => {
+        if (!isCurvedWall(event.node) ||
+            !options.currentLevelId ||
+            !isConicalRoofWallEligible(options.currentLevelId, event.node, options.getNodes())) {
+            return;
+        }
+        event.stopPropagation();
+        options.onSelect(event.node);
+    };
+    emitter.on('wall:enter', onWallHover);
+    emitter.on('wall:move', onWallHover);
+    emitter.on('wall:leave', onWallLeave);
+    emitter.on('wall:click', onWallClick);
+    return () => {
+        emitter.off('wall:enter', onWallHover);
+        emitter.off('wall:move', onWallHover);
+        emitter.off('wall:leave', onWallLeave);
+        emitter.off('wall:click', onWallClick);
+    };
+}
+export function resolveRoofFootprintElevation(targetLevelId, target, nodes) {
+    const completeNodes = nodes;
+    const elevations = getLevelElevations(completeNodes);
+    const tops = target.wallIds.flatMap((id) => {
+        const wall = nodes[id];
+        return wall?.type === 'wall'
+            ? [resolveRoofWallTopElevation(targetLevelId, wall, completeNodes, elevations)]
+            : [];
+    });
+    return tops.length ? Math.max(...tops) : 0;
+}
+export function resolveRoofFootprintWorldElevation(targetLevelId, target, nodes) {
+    const completeNodes = nodes;
+    const elevations = getLevelElevations(completeNodes);
+    return ((elevations.get(targetLevelId)?.baseY ?? 0) +
+        resolveRoofFootprintElevation(targetLevelId, target, nodes));
+}
+/**
+ * World/building-local Y for a wall-top preview rendered outside a level node.
+ *
+ * Roof nodes are parented to a level, so their stored position is relative to
+ * that level's floor. The conical wall hover ghost is rendered directly in the
+ * building group instead, and therefore needs the active level's world base
+ * added back after resolving the level-relative placement.
+ */
+export function resolveRoofWallTopWorldElevation(targetLevelId, wall, nodes, elevations = getLevelElevations(nodes)) {
+    return ((elevations.get(targetLevelId)?.baseY ?? 0) +
+        resolveRoofWallTopElevation(targetLevelId, wall, nodes, elevations));
+}

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

@@ -0,0 +1,18 @@
+export type RoofPlacementMode = 'auto' | 'ground' | 'roof';
+type RoofPlacementModeState = {
+    conical: boolean;
+    mode: RoofPlacementMode;
+    cycleMode: () => void;
+    setConical: (conical: boolean) => void;
+};
+declare const useRoofPlacementMode: import("zustand").UseBoundStore<import("zustand").StoreApi<RoofPlacementModeState>>;
+export declare const conicalRoofToolHintVisibility: {
+    subscribe: (onChange: () => void) => () => void;
+    value: () => boolean;
+};
+export declare const standardRoofToolHintVisibility: {
+    subscribe: (onChange: () => void) => () => void;
+    value: () => boolean;
+};
+export default useRoofPlacementMode;
+//# sourceMappingURL=roof-placement-mode.d.ts.map