@pascal-app/nodes 0.1.1

package/dist/dormer/panel-position-section.js

@@ -0,0 +1,162 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { sceneRegistry, useScene, } from '@pascal-app/core';
+import { PanelSection, SliderControl } from '@pascal-app/editor';
+import { useMemo } from 'react';
+import { Vector3 } from 'three';
+/**
+ * Position section: X, Z (world-space) and Rotation (world-space)
+ * sliders. Owns the read side of the dormer's world transform —
+ * confined to a single useMemo so the underlying `updateWorldMatrix`
+ * calls don't fire on unrelated re-renders. Also owns the segment-
+ * local commits, including the cross-segment reparent case.
+ */
+export function DormerPositionSection({ node, segment, roof, selectedId, previewProp, commitProp, }) {
+    const px = node.position[0];
+    const py = node.position[1];
+    const pz = node.position[2];
+    const nodeRotation = node.rotation;
+    const segmentId = segment?.id;
+    const roofChildrenKey = (roof?.children ?? []).join(',');
+    // biome-ignore lint/correctness/useExhaustiveDependencies: roofChildrenKey is the stable signature of `roof.children`; intentionally omitting `roof` (object identity) in favor of the joined ids.
+    const worldXform = useMemo(() => {
+        const dormerObj = sceneRegistry.nodes.get(selectedId);
+        let worldX = 0;
+        let worldZ = 0;
+        let worldRotation = nodeRotation ?? 0;
+        if (dormerObj) {
+            dormerObj.updateWorldMatrix(true, false);
+            const localPt = new Vector3(px ?? 0, 0, pz ?? 0);
+            const worldPt = localPt.applyMatrix4(dormerObj.matrixWorld);
+            worldX = worldPt.x;
+            worldZ = worldPt.z;
+            const m = dormerObj.matrixWorld.elements;
+            worldRotation = Math.atan2(-(m[2] ?? 0), m[0] ?? 1) + (nodeRotation ?? 0);
+        }
+        let bounds = null;
+        if (roof) {
+            const state = useScene.getState();
+            let lo_x = Number.POSITIVE_INFINITY;
+            let hi_x = Number.NEGATIVE_INFINITY;
+            let lo_z = Number.POSITIVE_INFINITY;
+            let hi_z = Number.NEGATIVE_INFINITY;
+            for (const childId of roof.children ?? []) {
+                const seg = state.nodes[childId];
+                if (!seg)
+                    continue;
+                const segObj = sceneRegistry.nodes.get(seg.id);
+                if (!segObj)
+                    continue;
+                segObj.updateWorldMatrix(true, false);
+                const segWorldCenter = new Vector3().applyMatrix4(segObj.matrixWorld);
+                const r = Math.hypot(seg.width, seg.depth) / 2;
+                lo_x = Math.min(lo_x, segWorldCenter.x - r);
+                hi_x = Math.max(hi_x, segWorldCenter.x + r);
+                lo_z = Math.min(lo_z, segWorldCenter.z - r);
+                hi_z = Math.max(hi_z, segWorldCenter.z + r);
+            }
+            if (Number.isFinite(lo_x))
+                bounds = { minX: lo_x, maxX: hi_x, minZ: lo_z, maxZ: hi_z };
+        }
+        return { worldX, worldZ, worldRotation, bounds };
+    }, [selectedId, px, py, pz, nodeRotation, segmentId, roofChildrenKey]);
+    const worldX_now = worldXform.worldX;
+    const worldZ_now = worldXform.worldZ;
+    const worldRotation_now = worldXform.worldRotation;
+    const worldMinX = worldXform.bounds?.minX ?? worldX_now - 20;
+    const worldMaxX = worldXform.bounds?.maxX ?? worldX_now + 20;
+    const worldMinZ = worldXform.bounds?.minZ ?? worldZ_now - 20;
+    const worldMaxZ = worldXform.bounds?.maxZ ?? worldZ_now + 20;
+    const findSegmentForWorldPoint = (wx, wz) => {
+        const state = useScene.getState();
+        const worldPt = new Vector3(wx, 0, wz);
+        for (const candidate of Object.values(state.nodes)) {
+            if (candidate?.type !== 'roof-segment')
+                continue;
+            const seg = candidate;
+            const segObj = sceneRegistry.nodes.get(seg.id);
+            if (!segObj)
+                continue;
+            segObj.updateWorldMatrix(true, false);
+            const local = segObj.worldToLocal(worldPt.clone());
+            if (Math.abs(local.x) <= seg.width / 2 && Math.abs(local.z) <= seg.depth / 2) {
+                return { segment: seg, localX: local.x, localZ: local.z };
+            }
+        }
+        return null;
+    };
+    const worldToSegLocal = (wx, wz, seg) => {
+        const segObj = sceneRegistry.nodes.get(seg.id);
+        if (!segObj)
+            return { localX: wx, localZ: wz };
+        segObj.updateWorldMatrix(true, false);
+        const local = segObj.worldToLocal(new Vector3(wx, 0, wz));
+        return { localX: local.x, localZ: local.z };
+    };
+    const commitWorldPosition = (newWorldX, newWorldZ) => {
+        if (!segment)
+            return;
+        const oldWorldRotation = worldRotation_now;
+        const target = findSegmentForWorldPoint(newWorldX, newWorldZ);
+        if (target && target.segment.id !== segment.id) {
+            // Moving to a different segment — segment-local Y is meaningless
+            // across the change, so reset to 0 and let the new segment's
+            // slope-anchored geometry take over.
+            const newSegObj = sceneRegistry.nodes.get(target.segment.id);
+            let newAncestorWorldY = 0;
+            if (newSegObj) {
+                newSegObj.updateWorldMatrix(true, false);
+                const m = newSegObj.matrixWorld.elements;
+                newAncestorWorldY = Math.atan2(-(m[2] ?? 0), m[0] ?? 1);
+            }
+            const newSegLocalRot = oldWorldRotation - newAncestorWorldY;
+            commitProp({
+                roofSegmentId: target.segment.id,
+                parentId: target.segment.id,
+                position: [target.localX, 0, target.localZ],
+                rotation: newSegLocalRot,
+            });
+        }
+        else {
+            // Same segment — preserve the existing Y so the dormer doesn't
+            // snap back to the segment foot when the user only adjusts X/Z.
+            const local = worldToSegLocal(newWorldX, newWorldZ, segment);
+            commitProp({ position: [local.localX, py ?? 0, local.localZ] });
+        }
+    };
+    const commitWorldRotation = (newWorldRot) => {
+        if (!segment)
+            return;
+        let ancestorWorldY = 0;
+        const segObj = sceneRegistry.nodes.get(segment.id);
+        if (segObj) {
+            segObj.updateWorldMatrix(true, false);
+            const m = segObj.matrixWorld.elements;
+            ancestorWorldY = Math.atan2(-(m[2] ?? 0), m[0] ?? 1);
+        }
+        commitProp({ rotation: newWorldRot - ancestorWorldY });
+    };
+    return (_jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(worldMaxX * 10) / 10, min: Math.round(worldMinX * 10) / 10, onChange: (newWorldX) => {
+                    if (!segment)
+                        return;
+                    const local = worldToSegLocal(newWorldX, worldZ_now, segment);
+                    previewProp({ position: [local.localX, py ?? 0, local.localZ] });
+                }, onCommit: (newWorldX) => commitWorldPosition(newWorldX, worldZ_now), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(worldX_now * 100) / 100 }), _jsx(SliderControl, { label: "Z", max: Math.round(worldMaxZ * 10) / 10, min: Math.round(worldMinZ * 10) / 10, onChange: (newWorldZ) => {
+                    if (!segment)
+                        return;
+                    const local = worldToSegLocal(worldX_now, newWorldZ, segment);
+                    previewProp({ position: [local.localX, py ?? 0, local.localZ] });
+                }, onCommit: (newWorldZ) => commitWorldPosition(worldX_now, newWorldZ), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(worldZ_now * 100) / 100 }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (degrees) => {
+                    const newWorldRot = (degrees * Math.PI) / 180;
+                    let ancestorWorldY = 0;
+                    if (segment) {
+                        const segObj = sceneRegistry.nodes.get(segment.id);
+                        if (segObj) {
+                            segObj.updateWorldMatrix(true, false);
+                            const m = segObj.matrixWorld.elements;
+                            ancestorWorldY = Math.atan2(-(m[2] ?? 0), m[0] ?? 1);
+                        }
+                    }
+                    previewProp({ rotation: newWorldRot - ancestorWorldY });
+                }, onCommit: (degrees) => commitWorldRotation((degrees * Math.PI) / 180), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round((worldRotation_now * 180) / Math.PI) })] }));
+}

package/dist/dormer/panel-window-section.d.ts

@@ -0,0 +1,14 @@
+import type { DormerNode } from '@pascal-app/core';
+/**
+ * The Window tab of the dormer inspector: Hung Wall, Opening, Shape
+ * (with rounded/arch sub-controls), Frame, Grid, Sill. Owns local UI
+ * state for the "All vs Individual" corner-radius view mode — derived
+ * from tuple uniformity by default.
+ */
+export declare function DormerWindowSection({ node, previewProp, commitProp, handleUpdate, }: {
+    node: DormerNode;
+    previewProp: (updates: Partial<DormerNode>) => void;
+    commitProp: (updates: Partial<DormerNode>) => void;
+    handleUpdate: (updates: Partial<DormerNode>) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=panel-window-section.d.ts.map

package/dist/dormer/panel-window-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-window-section.d.ts","sourceRoot":"","sources":["../../src/dormer/panel-window-section.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAWlD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,IAAI,EACJ,WAAW,EACX,UAAU,EACV,YAAY,GACb,EAAE;IACD,IAAI,EAAE,UAAU,CAAA;IAChB,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;IACnD,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;IAClD,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;CACrD,+BA6RA"}

package/dist/dormer/panel-window-section.js

@@ -0,0 +1,59 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { PanelSection, SegmentedControl, SliderControl, ToggleControl } from '@pascal-app/editor';
+import { useState } from 'react';
+function maxSharedRadius(width, height) {
+    return Math.max(0, Math.min(width / 2, height / 2));
+}
+/**
+ * The Window tab of the dormer inspector: Hung Wall, Opening, Shape
+ * (with rounded/arch sub-controls), Frame, Grid, Sill. Owns local UI
+ * state for the "All vs Individual" corner-radius view mode — derived
+ * from tuple uniformity by default.
+ */
+export function DormerWindowSection({ node, previewProp, commitProp, handleUpdate, }) {
+    const [radiusViewMode, setRadiusViewMode] = useState('all');
+    const windowShape = node.windowShape;
+    const windowCornerRadii = [...node.windowCornerRadii];
+    const windowArchHeight = node.windowArchHeight;
+    const maxRadius = Math.max(0.01, maxSharedRadius(node.windowWidth, node.windowHeight));
+    const tupleIsUniform = windowCornerRadii[0] === windowCornerRadii[1] &&
+        windowCornerRadii[1] === windowCornerRadii[2] &&
+        windowCornerRadii[2] === windowCornerRadii[3];
+    const sharedRadius = windowCornerRadii[0];
+    const setCornerRadius = (index, value, commit) => {
+        const next = [...windowCornerRadii];
+        next[index] = value;
+        if (commit)
+            commitProp({ windowCornerRadii: next });
+        else
+            previewProp({ windowCornerRadii: next });
+    };
+    const setAllCornerRadii = (value, commit) => {
+        const next = [value, value, value, value];
+        if (commit)
+            commitProp({ windowCornerRadii: next });
+        else
+            previewProp({ windowCornerRadii: next });
+    };
+    return (_jsxs(_Fragment, { children: [_jsx(PanelSection, { title: "Hung Wall", children: _jsx(SliderControl, { label: "Height", max: 6, min: 0.2, onChange: (v) => previewProp({ wallSkirtHeight: v }), onCommit: (v) => commitProp({ wallSkirtHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.wallSkirtHeight * 100) / 100 }) }), _jsxs(PanelSection, { title: "Opening", children: [_jsx(SliderControl, { label: "Width", max: Math.max(0.5, node.width - 0.1), min: 0.2, onChange: (v) => previewProp({ windowWidth: v }), onCommit: (v) => commitProp({ windowWidth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.windowWidth * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: Math.max(0.2, node.wallSkirtHeight - 0.1), min: 0.2, onChange: (v) => previewProp({ windowHeight: v }), onCommit: (v) => commitProp({ windowHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.windowHeight * 100) / 100 }), _jsx(SliderControl, { label: "Offset X", max: 1, min: -1, onChange: (v) => previewProp({ windowOffsetX: v }), onCommit: (v) => commitProp({ windowOffsetX: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.windowOffsetX * 100) / 100 }), _jsx(SliderControl, { label: "Offset Y", max: 2, min: 0, onChange: (v) => previewProp({ windowOffsetY: v }), onCommit: (v) => commitProp({ windowOffsetY: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.windowOffsetY * 100) / 100 })] }), _jsxs(PanelSection, { title: "Shape", children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({
+                            windowShape: v,
+                            ...(v === 'rounded'
+                                ? {
+                                    windowCornerRadii: windowCornerRadii.map((r) => Math.min(r, maxRadius)),
+                                }
+                                : {}),
+                        }), options: [
+                            { value: 'rectangle', label: 'Rect' },
+                            { value: 'rounded', label: 'Rounded' },
+                            { value: 'arch', label: 'Arch' },
+                        ], value: windowShape }), windowShape === 'rounded' && (_jsxs("div", { className: "mt-2 flex flex-col gap-1", children: [_jsx(SegmentedControl, { onChange: (v) => setRadiusViewMode(v), options: [
+                                    { value: 'all', label: 'All' },
+                                    { value: 'individual', label: 'Individual' },
+                                ], value: tupleIsUniform ? radiusViewMode : 'individual' }), tupleIsUniform && radiusViewMode === 'all' ? (_jsx(SliderControl, { label: "Corner Radius", max: maxRadius, min: 0, onChange: (v) => setAllCornerRadii(v, false), onCommit: (v) => setAllCornerRadii(v, true), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(sharedRadius * 100) / 100 })) : ([
+                                ['Top Left', 0],
+                                ['Top Right', 1],
+                                ['Bottom Right', 2],
+                                ['Bottom Left', 3],
+                            ].map(([label, index]) => (_jsx(SliderControl, { label: label, max: maxRadius, min: 0, onChange: (v) => setCornerRadius(index, v, false), onCommit: (v) => setCornerRadius(index, v, true), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round((windowCornerRadii[index] ?? 0) * 100) / 100 }, label))))] })), windowShape === 'arch' && (_jsx(SliderControl, { label: "Arch Height", max: Math.max(0.1, node.windowHeight), min: 0.1, onChange: (v) => previewProp({ windowArchHeight: v }), onCommit: (v) => commitProp({ windowArchHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(windowArchHeight * 100) / 100 }))] }), _jsxs(PanelSection, { title: "Frame", children: [_jsx(SliderControl, { label: "Thickness", max: 0.15, min: 0.01, onChange: (v) => previewProp({ windowFrameThickness: v }), onCommit: (v) => commitProp({ windowFrameThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round(node.windowFrameThickness * 1000) / 1000 }), _jsx(SliderControl, { label: "Depth", max: 0.15, min: 0.02, onChange: (v) => previewProp({ windowFrameDepth: v }), onCommit: (v) => commitProp({ windowFrameDepth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round(node.windowFrameDepth * 1000) / 1000 }), _jsx(SliderControl, { label: "Divider", max: 0.06, min: 0, onChange: (v) => previewProp({ windowDividerThickness: v }), onCommit: (v) => commitProp({ windowDividerThickness: v }), precision: 3, restoreOnCommit: false, step: 0.002, unit: "m", value: Math.round(node.windowDividerThickness * 1000) / 1000 })] }), _jsxs(PanelSection, { title: "Grid", children: [_jsx(SliderControl, { label: "Columns", max: 8, min: 1, onChange: (v) => previewProp({ windowColumns: Math.max(1, Math.min(8, Math.round(v))) }), onCommit: (v) => commitProp({ windowColumns: Math.max(1, Math.min(8, Math.round(v))) }), precision: 0, restoreOnCommit: false, step: 1, value: node.windowColumns }), _jsx(SliderControl, { label: "Rows", max: 8, min: 1, onChange: (v) => previewProp({ windowRows: Math.max(1, Math.min(8, Math.round(v))) }), onCommit: (v) => commitProp({ windowRows: Math.max(1, Math.min(8, Math.round(v))) }), precision: 0, restoreOnCommit: false, step: 1, value: node.windowRows })] }), _jsxs(PanelSection, { title: "Sill", children: [_jsx(ToggleControl, { checked: node.windowSill, label: "Enable Sill", onChange: (checked) => handleUpdate({ windowSill: checked }) }), node.windowSill && (_jsxs("div", { className: "mt-1 flex flex-col gap-1", children: [_jsx(SliderControl, { label: "Depth", max: 0.3, min: 0.02, onChange: (v) => previewProp({ windowSillDepth: v }), onCommit: (v) => commitProp({ windowSillDepth: v }), precision: 3, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(node.windowSillDepth * 1000) / 1000 }), _jsx(SliderControl, { label: "Thickness", max: 0.1, min: 0.01, onChange: (v) => previewProp({ windowSillThickness: v }), onCommit: (v) => commitProp({ windowSillThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round(node.windowSillThickness * 1000) / 1000 })] }))] })] }));
+}

package/dist/dormer/panel.d.ts

@@ -0,0 +1,2 @@
+export default function DormerPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=panel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/dormer/panel.tsx"],"names":[],"mappings":"AA2CA,MAAM,CAAC,OAAO,UAAU,WAAW,uCA0PlC"}

package/dist/dormer/panel.js

@@ -0,0 +1,134 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { cn, PanelSection, PanelWrapper, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useCallback, useState } from 'react';
+import { DormerActionsSection } from './panel-actions-section';
+import { DormerPositionSection } from './panel-position-section';
+import { DormerWindowSection } from './panel-window-section';
+const ROOF_TYPE_OPTIONS = [
+    { label: 'Gable', value: 'gable' },
+    { label: 'Hip', value: 'hip' },
+    { label: 'Shed', value: 'shed' },
+    { label: 'Gambrel', value: 'gambrel' },
+    { label: 'Dutch', value: 'dutch' },
+    { label: 'Mansard', value: 'mansard' },
+    { label: 'Flat', value: 'flat' },
+];
+const SECTION_OPTIONS = [
+    { label: 'Dormer', value: 'dormer' },
+    { label: 'Window', value: 'window' },
+];
+export default function DormerPanel() {
+    const [section, setSection] = useState('dormer');
+    const selectedId = useViewer((s) => s.selection.selectedIds[0]);
+    const setSelection = useViewer((s) => s.setSelection);
+    const updateNode = useScene((s) => s.updateNode);
+    const deleteNode = useScene((s) => s.deleteNode);
+    const setMovingNode = useEditor((s) => s.setMovingNode);
+    const storeNode = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    const overrides = useLiveNodeOverrides((s) => selectedId ? s.get(selectedId) : undefined);
+    const node = storeNode && overrides ? { ...storeNode, ...overrides } : storeNode;
+    const handleUpdate = useCallback((updates) => {
+        if (!selectedId)
+            return;
+        updateNode(selectedId, updates);
+    }, [selectedId, updateNode]);
+    // Slider drag → write live override; release → commit.
+    const previewProp = useCallback((updates) => {
+        if (!selectedId)
+            return;
+        useLiveNodeOverrides.getState().set(selectedId, updates);
+    }, [selectedId]);
+    const commitProp = useCallback((updates) => {
+        if (!selectedId)
+            return;
+        updateNode(selectedId, updates);
+        if (updates.roofSegmentId !== undefined) {
+            const state = useScene.getState();
+            const prev = node?.roofSegmentId;
+            if (prev)
+                state.dirtyNodes.add(prev);
+            state.dirtyNodes.add(updates.roofSegmentId);
+            state.dirtyNodes.add(selectedId);
+        }
+        useLiveNodeOverrides.getState().clear(selectedId);
+    }, [node, selectedId, updateNode]);
+    const handleClose = useCallback(() => {
+        setSelection({ selectedIds: [] });
+    }, [setSelection]);
+    const handleBack = useCallback(() => {
+        if (node?.roofSegmentId) {
+            setSelection({ selectedIds: [node.roofSegmentId] });
+        }
+    }, [node?.roofSegmentId, setSelection]);
+    const handleMove = useCallback(() => {
+        if (!(node && selectedId))
+            return;
+        triggerSFX('sfx:item-pick');
+        setMovingNode(node);
+        setSelection({ selectedIds: [] });
+    }, [node, selectedId, setMovingNode, setSelection]);
+    const handleDuplicate = useCallback(() => {
+        if (!node?.roofSegmentId)
+            return;
+        triggerSFX('sfx:item-pick');
+        // Deep clone and strip the id so the move tool's onClick branch
+        // (`isNew || !node.id`) takes the "create fresh" path. Setting
+        // `metadata.isNew = true` is what gates the move tool from
+        // updating any existing node — the dormer is only added to the
+        // scene on click, not when the Duplicate button is pressed.
+        const cloned = structuredClone(node);
+        delete cloned.id;
+        const prevMeta = cloned.metadata && typeof cloned.metadata === 'object' && !Array.isArray(cloned.metadata)
+            ? cloned.metadata
+            : {};
+        cloned.metadata = { ...prevMeta, isNew: true };
+        setMovingNode(cloned);
+        setSelection({ selectedIds: [] });
+    }, [node, setMovingNode, setSelection]);
+    const handleDelete = useCallback(() => {
+        if (!(selectedId && node))
+            return;
+        triggerSFX('sfx:item-delete');
+        const segmentId = node.roofSegmentId;
+        if (segmentId) {
+            const state = useScene.getState();
+            const segment = state.nodes[segmentId];
+            if (segment) {
+                state.updateNode(segmentId, {
+                    children: (segment.children ?? []).filter((id) => id !== selectedId),
+                });
+            }
+        }
+        deleteNode(selectedId);
+        if (segmentId) {
+            useScene.getState().dirtyNodes.add(segmentId);
+            setSelection({ selectedIds: [segmentId] });
+        }
+        else {
+            setSelection({ selectedIds: [] });
+        }
+    }, [selectedId, node, deleteNode, setSelection]);
+    if (!(node && node.type === 'dormer' && selectedId))
+        return null;
+    const scenestate = useScene.getState();
+    const segment = node.roofSegmentId
+        ? scenestate.nodes[node.roofSegmentId]
+        : undefined;
+    const roof = segment?.parentId
+        ? scenestate.nodes[segment.parentId]
+        : undefined;
+    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || 'Dormer', width: 300, children: [_jsx(DormerPositionSection, { commitProp: commitProp, node: node, previewProp: previewProp, roof: roof, segment: segment, selectedId: selectedId }), _jsx(PanelSection, { title: "Section", children: _jsx("div", { className: "grid grid-cols-3 gap-1.5 px-1 pt-1", children: SECTION_OPTIONS.map((option) => {
+                        const isSelected = section === option.value;
+                        return (_jsx("button", { className: cn('flex min-h-10 items-center justify-center rounded-lg border px-2 py-2 text-center text-xs transition-colors', isSelected
+                                ? 'border-orange-400/60 bg-orange-400/10 text-foreground'
+                                : 'border-border/50 bg-[#2C2C2E] text-muted-foreground hover:bg-[#3e3e3e] hover:text-foreground'), onClick: () => setSection(option.value), type: "button", children: _jsx("span", { className: "truncate font-medium", children: option.label }) }, option.value));
+                    }) }) }), section === 'dormer' && (_jsxs(_Fragment, { children: [_jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Width", max: 4, min: 0.5, onChange: (v) => previewProp({ width: v }), onCommit: (v) => commitProp({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.width * 100) / 100 }), _jsx(SliderControl, { label: "Depth", max: 5, min: 0.5, onChange: (v) => previewProp({ depth: v }), onCommit: (v) => commitProp({ depth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.depth * 100) / 100 }), _jsx(SliderControl, { label: "Wall Height", max: 5, min: 0, onChange: (v) => previewProp({ height: v }), onCommit: (v) => commitProp({ height: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.height * 100) / 100 }), _jsx(SliderControl, { label: "Roof Height", max: 3, min: 0, onChange: (v) => previewProp({ roofHeight: v }), onCommit: (v) => commitProp({ roofHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.roofHeight * 100) / 100 })] }), _jsx(PanelSection, { title: "Roof Type", children: _jsx("div", { className: "grid grid-cols-3 gap-1.5 px-1 pt-1", children: ROOF_TYPE_OPTIONS.map((option) => {
+                                const isSelected = node.roofType === option.value;
+                                return (_jsx("button", { className: cn('flex min-h-10 items-center justify-center rounded-lg border px-2 py-2 text-xs transition-colors', isSelected
+                                        ? 'border-orange-400/60 bg-orange-400/10 text-foreground'
+                                        : 'border-border/50 bg-[#2C2C2E] text-muted-foreground hover:bg-[#3e3e3e] hover:text-foreground'), onClick: () => handleUpdate({ roofType: option.value }), type: "button", children: _jsx("span", { className: "truncate font-medium", children: option.label }) }, option.value));
+                            }) }) })] })), section === 'window' && (_jsx(DormerWindowSection, { commitProp: commitProp, handleUpdate: handleUpdate, node: node, previewProp: previewProp })), _jsx(DormerActionsSection, { onDelete: handleDelete, onDuplicate: handleDuplicate, onMove: handleMove })] }));
+}

package/dist/dormer/parametrics.d.ts

@@ -0,0 +1,4 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { DormerNode } from './schema';
+export declare const dormerParametrics: ParametricDescriptor<DormerNode>;
+//# sourceMappingURL=parametrics.d.ts.map

package/dist/dormer/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/dormer/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,iBAAiB,EAAE,oBAAoB,CAAC,UAAU,CA4G9D,CAAA"}

package/dist/dormer/parametrics.js

@@ -0,0 +1,110 @@
+import { dormerSupportsArch } from './geometry';
+export const dormerParametrics = {
+    // Bespoke tabbed UI (Dormer / Window / Frame / Grid / Sill) — same
+    // pattern as chimney. `groups` stays for the MCP path / fallback
+    // consumer, but the inspector mounts the custom panel.
+    customPanel: () => import('./panel'),
+    groups: [
+        {
+            label: 'Dormer',
+            fields: [
+                { key: 'width', kind: 'number', unit: 'm', min: 0.5, max: 4, step: 0.05 },
+                { key: 'depth', kind: 'number', unit: 'm', min: 0.5, max: 5, step: 0.05 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0, max: 5, step: 0.05 },
+            ],
+        },
+        {
+            label: 'Dormer roof',
+            fields: [
+                {
+                    key: 'roofType',
+                    kind: 'enum',
+                    options: ['hip', 'gable', 'shed', 'gambrel', 'dutch', 'mansard', 'flat'],
+                    display: 'select',
+                },
+                { key: 'roofHeight', kind: 'number', unit: 'm', min: 0, max: 2, step: 0.05 },
+            ],
+        },
+        {
+            label: 'Hung wall',
+            fields: [{ key: 'wallSkirtHeight', kind: 'number', unit: 'm', min: 0.2, max: 6, step: 0.05 }],
+        },
+        {
+            label: 'Window opening',
+            fields: [
+                { key: 'windowWidth', kind: 'number', unit: 'm', min: 0.2, max: 3, step: 0.05 },
+                { key: 'windowHeight', kind: 'number', unit: 'm', min: 0.2, max: 6, step: 0.05 },
+                { key: 'windowOffsetX', kind: 'number', unit: 'm', min: -1, max: 1, step: 0.05 },
+                { key: 'windowOffsetY', kind: 'number', unit: 'm', min: 0, max: 2, step: 0.05 },
+            ],
+        },
+        {
+            label: 'Window grid',
+            fields: [
+                { key: 'windowColumns', kind: 'number', min: 1, max: 8, step: 1 },
+                { key: 'windowRows', kind: 'number', min: 1, max: 8, step: 1 },
+            ],
+        },
+        {
+            label: 'Window frame',
+            fields: [
+                {
+                    key: 'windowFrameThickness',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.01,
+                    max: 0.15,
+                    step: 0.005,
+                },
+                { key: 'windowFrameDepth', kind: 'number', unit: 'm', min: 0.02, max: 0.15, step: 0.005 },
+                {
+                    key: 'windowDividerThickness',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0,
+                    max: 0.06,
+                    step: 0.002,
+                },
+                {
+                    key: 'windowShape',
+                    kind: 'enum',
+                    options: ['rectangle', 'rounded', 'arch'],
+                    display: 'segmented',
+                },
+                {
+                    key: 'windowArchHeight',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.1,
+                    max: 1,
+                    step: 0.05,
+                    visibleIf: dormerSupportsArch,
+                },
+            ],
+        },
+        {
+            label: 'Sill',
+            fields: [
+                { key: 'windowSill', kind: 'boolean' },
+                {
+                    key: 'windowSillDepth',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.02,
+                    max: 0.3,
+                    step: 0.01,
+                    visibleIf: (n) => n.windowSill === true,
+                },
+                {
+                    key: 'windowSillThickness',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.01,
+                    max: 0.1,
+                    step: 0.005,
+                    visibleIf: (n) => n.windowSill === true,
+                },
+            ],
+        },
+    ],
+};

package/dist/dormer/placement-guides.d.ts

@@ -0,0 +1,28 @@
+import type { RoofSegmentNode } from '@pascal-app/core';
+type Vec3 = [number, number, number];
+/**
+ * Live "distance to roof edge" guides shown while a dormer ghost is being
+ * placed or dragged — the roof-plane analog of the window's sill/head +
+ * edge-proximity pills. Renders measured lines from each side-center of
+ * the dormer's occupied roof area out to the active roof face edges, each
+ * with a distance pill at its midpoint.
+ *
+ * Mounted as a sibling of `<DormerPreview>` INSIDE the segment-local frame
+ * (the `segmentXform` group) but OUTSIDE the dormer's `hitLocal` + rotation
+ * groups, so its coordinates are segment-local. The roof-face boundary is
+ * resolved from the actual visible top face under `center`, not from the
+ * wall footprint dimensions.
+ *
+ * Normal roof accessories use side-center readouts. Linear accessories
+ * like ridge vents and gutters use their own two-end guide mode.
+ */
+export declare function DormerPlacementGuides({ segment, center, width, depth, rotation, movingId, }: {
+    segment: RoofSegmentNode;
+    center: Vec3;
+    width: number;
+    depth: number;
+    rotation: number;
+    movingId?: string;
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=placement-guides.d.ts.map

package/dist/dormer/placement-guides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placement-guides.d.ts","sourceRoot":"","sources":["../../src/dormer/placement-guides.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AA0CvD,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAgBpC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,OAAO,EACP,MAAM,EACN,KAAK,EACL,KAAK,EACL,QAAQ,EACR,QAAQ,GACT,EAAE;IACD,OAAO,EAAE,eAAe,CAAA;IACxB,MAAM,EAAE,IAAI,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,+BAiGA"}