@pascal-app/nodes 0.1.1

package/dist/dormer/placement-guides.js

@@ -0,0 +1,170 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { EDITOR_LAYER, formatMeasurement } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Html } from '@react-three/drei';
+import { useEffect, useMemo } from 'react';
+import { BufferGeometry, Float32BufferAttribute, Line as ThreeLine } from 'three';
+import { LineBasicNodeMaterial } from 'three/webgpu';
+import { getRoofSurfaceFaceBoundsAt } from '../shared/roof-surface';
+import { roofFaceKey, roofGuideBounds, roofSiblingSpacing, } from '../shared/roof-surface-placement-guides';
+// Indigo — matches the wall/window 3D proximity guide accent so every
+// "distance to edge" readout reads the same across the app.
+const GUIDE_COLOR = 0x81_8c_f8;
+const ALIGN_COLOR = 0xef_44_44;
+const PILL_BG = '#6366f1';
+const BADGE_BG = '#ec4899';
+// Lift the lines a hair off the sloped surface so they don't z-fight the
+// roof + dormer ghost.
+const SURFACE_LIFT = 0.02;
+// Hide a gap that has collapsed (dormer edge flush to / past the roof edge)
+// so we don't draw a degenerate "0m" pill.
+const MIN_GAP_M = 0.02;
+const guideMaterial = new LineBasicNodeMaterial({
+    color: GUIDE_COLOR,
+    depthTest: false,
+    depthWrite: false,
+    toneMapped: false,
+    transparent: true,
+});
+const alignMaterial = new LineBasicNodeMaterial({
+    color: ALIGN_COLOR,
+    depthTest: false,
+    depthWrite: false,
+    toneMapped: false,
+    transparent: true,
+});
+/**
+ * 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 function DormerPlacementGuides({ segment, center, width, depth, rotation, movingId, }) {
+    const unit = useViewer((s) => s.unit);
+    const [cx, , cz] = center;
+    const faceBounds = getRoofSurfaceFaceBoundsAt(segment, cx, cz);
+    const halfW = Math.max(0, width) / 2;
+    const halfD = Math.max(0, depth) / 2;
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    const halfX = Math.abs(cos) * halfW + Math.abs(sin) * halfD;
+    const halfZ = Math.abs(sin) * halfW + Math.abs(cos) * halfD;
+    const movingBounds = roofGuideBounds(center, { width, depth, rotation });
+    const surfaceY = (x, z) => faceBounds.surfaceYAt(x, z) + SURFACE_LIFT;
+    const xInterval = faceBounds.xIntervalAtZ(cz);
+    const zInterval = faceBounds.zIntervalAtX(cx);
+    const guides = [];
+    const push = (id, ax, az, bx, bz) => {
+        const from = [ax, surfaceY(ax, az), az];
+        const to = [bx, surfaceY(bx, bz), bz];
+        const value = Math.hypot(to[0] - from[0], to[1] - from[1], to[2] - from[2]);
+        if (value < MIN_GAP_M)
+            return;
+        guides.push({
+            id,
+            from,
+            to,
+            kind: 'dimension',
+            value,
+        });
+    };
+    const siblingSpacing = roofSiblingSpacing({
+        segment,
+        movingId,
+        movingBounds,
+        faceKey: roofFaceKey(faceBounds.polygon),
+        dimension: (id, [ax, az], [bx, bz]) => {
+            const from = [ax, surfaceY(ax, az), az];
+            const to = [bx, surfaceY(bx, bz), bz];
+            const value = Math.hypot(to[0] - from[0], to[1] - from[1], to[2] - from[2]);
+            if (value < MIN_GAP_M)
+                return null;
+            return { id, from, to, kind: 'dimension', value };
+        },
+        alignLine: (id, [ax, az], [bx, bz]) => {
+            const from = [ax, surfaceY(ax, az), az];
+            const to = [bx, surfaceY(bx, bz), bz];
+            const value = Math.hypot(to[0] - from[0], to[1] - from[1], to[2] - from[2]);
+            if (value < MIN_GAP_M)
+                return null;
+            return { id, from, to, kind: 'align-line' };
+        },
+        badge: (id, [x, z], value) => {
+            if (value < MIN_GAP_M)
+                return null;
+            return {
+                id,
+                at: [x, surfaceY(x, z), z],
+                kind: 'badge',
+                value,
+            };
+        },
+        measure: ([ax, az], [bx, bz]) => {
+            const ay = surfaceY(ax, az);
+            const by = surfaceY(bx, bz);
+            return Math.hypot(bx - ax, by - ay, bz - az);
+        },
+    });
+    if (xInterval) {
+        const [faceMinX, faceMaxX] = xInterval;
+        const itemMinX = Math.max(faceMinX, Math.min(faceMaxX, cx - halfX));
+        const itemMaxX = Math.max(faceMinX, Math.min(faceMaxX, cx + halfX));
+        if (!siblingSpacing.blockedSides.left && itemMinX > faceMinX + MIN_GAP_M) {
+            push('left', faceMinX, cz, itemMinX, cz);
+        }
+        if (!siblingSpacing.blockedSides.right && itemMaxX < faceMaxX - MIN_GAP_M) {
+            push('right', itemMaxX, cz, faceMaxX, cz);
+        }
+    }
+    if (zInterval) {
+        const [faceMinZ, faceMaxZ] = zInterval;
+        const itemMinZ = Math.max(faceMinZ, Math.min(faceMaxZ, cz - halfZ));
+        const itemMaxZ = Math.max(faceMinZ, Math.min(faceMaxZ, cz + halfZ));
+        if (!siblingSpacing.blockedSides.bottom && itemMinZ > faceMinZ + MIN_GAP_M) {
+            push('back', cx, faceMinZ, cx, itemMinZ);
+        }
+        if (!siblingSpacing.blockedSides.top && itemMaxZ < faceMaxZ - MIN_GAP_M) {
+            push('front', cx, itemMaxZ, cx, faceMaxZ);
+        }
+    }
+    guides.push(...siblingSpacing.guides);
+    return (_jsx(_Fragment, { children: guides.map((g) => (_jsx(Guide, { guide: g, unit: unit }, g.id))) }));
+}
+function Guide({ guide, unit }) {
+    if (guide.kind === 'badge') {
+        return _jsx(GuideBadge, { at: guide.at, pill: `= ${formatMeasurement(guide.value, unit)}` });
+    }
+    return (_jsx(GuideLine, { from: guide.from, kind: guide.kind, pill: guide.value === undefined ? undefined : formatMeasurement(guide.value, unit), to: guide.to }));
+}
+function GuideBadge({ at, pill }) {
+    return (_jsx(Html, { center: true, position: at, style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [20, 0], children: _jsx("div", { className: "whitespace-nowrap rounded-[3px] px-[5px] py-[2px] font-semibold font-sans text-[11px] text-white", style: { backgroundColor: BADGE_BG }, children: pill }) }));
+}
+function GuideLine({ from, to, pill, kind, }) {
+    const { line, position } = useMemo(() => {
+        const position = new Float32BufferAttribute(new Float32Array(6), 3);
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', position);
+        const line = new ThreeLine(geometry, kind === 'align-line' ? alignMaterial : guideMaterial);
+        line.frustumCulled = false;
+        line.layers.set(EDITOR_LAYER);
+        line.renderOrder = 1000;
+        return { line, position };
+    }, [kind]);
+    position.setXYZ(0, from[0], from[1], from[2]);
+    position.setXYZ(1, to[0], to[1], to[2]);
+    position.needsUpdate = true;
+    useEffect(() => () => line.geometry.dispose(), [line]);
+    const mid = [(from[0] + to[0]) / 2, (from[1] + to[1]) / 2, (from[2] + to[2]) / 2];
+    return (_jsxs(_Fragment, { children: [_jsx("primitive", { object: line }), pill ? (_jsx(Html, { center: true, position: mid, style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [20, 0], children: _jsx("div", { className: "whitespace-nowrap rounded-[3px] px-[5px] py-[2px] font-medium font-sans text-[11px] text-white", style: { backgroundColor: PILL_BG }, children: pill }) })) : null] }));
+}

package/dist/dormer/preview.d.ts

@@ -0,0 +1,7 @@
+import type { DormerNode } from './schema';
+declare const DormerPreview: ({ node, invalid }: {
+    node: DormerNode;
+    invalid?: boolean;
+}) => import("react").JSX.Element;
+export default DormerPreview;
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/dormer/preview.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAmB1C,QAAA,MAAM,aAAa,GAAI,mBAAmB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,gCAYhF,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/dormer/preview.js

@@ -0,0 +1,29 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo } from 'react';
+import * as THREE from 'three';
+import { INVALID_GHOST_COLOR } from '../shared/ghost-materials';
+import { buildDormerGhostGeometry } from './geometry';
+const ghostMaterial = new THREE.MeshStandardMaterial({
+    color: 0x88_88_88,
+    transparent: true,
+    opacity: 0.45,
+    depthWrite: false,
+});
+const invalidGhostMaterial = new THREE.MeshStandardMaterial({
+    color: INVALID_GHOST_COLOR,
+    emissive: INVALID_GHOST_COLOR,
+    emissiveIntensity: 0.12,
+    roughness: 0.5,
+    transparent: true,
+    opacity: 0.4,
+    depthWrite: false,
+});
+const DormerPreview = ({ node, invalid }) => {
+    const material = invalid ? invalidGhostMaterial : ghostMaterial;
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const geo = useMemo(() => buildDormerGhostGeometry(node), [node.width, node.depth, node.height, node.roofHeight, node.roofType, node.wallSkirtHeight]);
+    useEffect(() => () => geo.dispose(), [geo]);
+    return _jsx("mesh", { geometry: geo, material: material, raycast: () => { } });
+};
+export default DormerPreview;

package/dist/dormer/renderer.d.ts

@@ -0,0 +1,8 @@
+import { type DormerNode } from '@pascal-app/core';
+import { DORMER_GABLE_MATERIAL_INDEX } from './csg-geometry';
+declare const DormerRenderer: ({ node: storeNode }: {
+    node: DormerNode;
+}) => import("react").JSX.Element | null;
+export { DORMER_GABLE_MATERIAL_INDEX };
+export default DormerRenderer;
+//# sourceMappingURL=renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/dormer/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAMhB,MAAM,kBAAkB,CAAA;AAYzB,OAAO,EAEL,2BAA2B,EAE5B,MAAM,gBAAgB,CAAA;AAGvB,QAAA,MAAM,cAAc,GAAI,qBAAqB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,uCA+KhE,CAAA;AAID,OAAO,EAAE,2BAA2B,EAAE,CAAA;AAEtC,eAAe,cAAc,CAAA"}

package/dist/dormer/renderer.js

@@ -0,0 +1,134 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getEffectiveDormerSurfaceMaterial, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useSegmentTrimClippedGeometry } from '../shared/use-segment-trim-clip';
+import { buildDormerFallbackGeometry, DORMER_GABLE_MATERIAL_INDEX, generateDormerGeometry, } from './csg-geometry';
+import DormerWindowAssembly from './window-assembly';
+const DormerRenderer = ({ node: storeNode }) => {
+    const ref = useRef(null);
+    useRegistry(storeNode.id, 'dormer', ref);
+    const handlers = useNodeEvents(storeNode, 'dormer');
+    // Live overrides so slider drag updates the dormer without committing
+    // to the store. While any override is live we render the cheap
+    // fallback silhouette — running the full CSG on every pointer move is
+    // far too expensive (multiple boolean ops + ground subtract +
+    // 32-segment arch curves). Commit clears the override and the real
+    // CSG mesh kicks back in.
+    const liveOverrides = useLiveNodeOverrides((state) => state.get(storeNode.id));
+    const isLiveDrag = !!liveOverrides && Object.keys(liveOverrides).length > 0;
+    const node = useMemo(() => (liveOverrides ? { ...storeNode, ...liveOverrides } : storeNode), [storeNode, liveOverrides]);
+    const segment = useScene((state) => node.roofSegmentId
+        ? state.nodes[node.roofSegmentId]
+        : undefined);
+    const shading = useViewer((s) => s.shading);
+    const textures = useViewer((s) => s.textures);
+    const colorPreset = useViewer((s) => s.colorPreset);
+    const sceneTheme = useViewer((s) => s.sceneTheme);
+    // Geometry material slots: 0=Wall, 1=Deck/side, 2=Interior, 3=Roof
+    // shingle, 4=Gable wall. Walls take the 'wall' role, the deck side and
+    // shingle take 'roof'. When textures are off, every slot snaps to its
+    // role colour regardless of explicit paint (the render-modes invariant).
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const material = useMemo(() => {
+        const wallRole = () => createSurfaceRoleMaterial('wall', colorPreset, undefined, sceneTheme);
+        const roofRole = () => createSurfaceRoleMaterial('roof', colorPreset, undefined, sceneTheme);
+        const top = getEffectiveDormerSurfaceMaterial(node, 'top');
+        const side = getEffectiveDormerSurfaceMaterial(node, 'side');
+        const wall = getEffectiveDormerSurfaceMaterial(node, 'wall');
+        const resolve = (spec, role) => {
+            if (!textures)
+                return role();
+            if (spec.materialPreset)
+                return createMaterialFromPresetRef(spec.materialPreset, shading) ?? role();
+            if (spec.material)
+                return createMaterial(spec.material, shading);
+            return role();
+        };
+        const w = resolve(wall, wallRole);
+        const s = resolve(side, roofRole);
+        const t = resolve(top, roofRole);
+        return [w, s, w, t, w];
+    }, [
+        textures,
+        colorPreset,
+        sceneTheme,
+        shading,
+        node.material,
+        node.materialPreset,
+        node.topMaterial,
+        node.topMaterialPreset,
+        node.sideMaterial,
+        node.sideMaterialPreset,
+        node.wallMaterial,
+        node.wallMaterialPreset,
+    ]);
+    // The window frame bars / sill take the 'joinery' role when untextured;
+    // otherwise the deck-side material (slot 1) drives the frame look.
+    const frameSideMat = useMemo(() => {
+        if (!textures)
+            return createSurfaceRoleMaterial('joinery', colorPreset, undefined, sceneTheme);
+        return material[1];
+    }, [textures, colorPreset, sceneTheme, material]);
+    // Dormer window glass has no per-node material — it always takes the
+    // themed 'glazing' role (semi-transparent) in both texture modes.
+    const glassMat = useMemo(() => createSurfaceRoleMaterial('glazing', colorPreset, undefined, sceneTheme), [colorPreset, sceneTheme]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const geometry = useMemo(() => {
+        if (!segment)
+            return null;
+        if (isLiveDrag)
+            return buildDormerFallbackGeometry(node);
+        return generateDormerGeometry(node, segment);
+    }, [
+        isLiveDrag,
+        segment,
+        node.id,
+        node.roofType,
+        node.width,
+        node.depth,
+        node.height,
+        node.roofHeight,
+        node.wallSkirtHeight,
+        node.position[0],
+        node.position[1],
+        node.position[2],
+        node.rotation,
+        node.windowWidth,
+        node.windowHeight,
+        node.windowOffsetX,
+        node.windowOffsetY,
+        node.windowShape,
+        node.windowArchHeight,
+        node.windowCornerRadii[0],
+        node.windowCornerRadii[1],
+        node.windowCornerRadii[2],
+        node.windowCornerRadii[3],
+    ]);
+    useEffect(() => () => geometry?.dispose(), [geometry]);
+    // Map dormer-local geometry into the host segment's local frame (where the
+    // trim cut prisms live) — same pose the inner mesh group is mounted with.
+    const localToSegment = useMemo(() => new THREE.Matrix4().compose(new THREE.Vector3(node.position[0] ?? 0, node.position[1] ?? 0, node.position[2] ?? 0), new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), node.rotation ?? 0), new THREE.Vector3(1, 1, 1)), [node.position[0], node.position[1], node.position[2], node.rotation]);
+    const clippedGeometry = useSegmentTrimClippedGeometry(geometry, segment, localToSegment);
+    if (!(segment && geometry))
+        return null;
+    // Dormers are mounted inside `RoofRenderer`'s `roof-elements` group
+    // (at the roof origin — NOT inside the host segment's transform), so
+    // we apply the segment's own position + rotation here. Mirrors how
+    // chimney / skylight render. The CSG geometry is built in
+    // dormer-mesh-local with `dormer.position` + `dormer.rotation`
+    // already accounted for by `segToMesh`, so we layer them as group
+    // transforms here too.
+    //
+    // The registered ref sits on the inner group that applies the
+    // dormer's own position + rotation so the registered Object3D's
+    // local frame is *dormer-local* — that's what `NodeArrowHandles`
+    // reads to place its chevrons. Mirrors chimney's structure.
+    return (_jsx("group", { position: segment.position, "rotation-y": segment.rotation ?? 0, visible: node.visible, ...handlers, children: _jsxs("group", { position: [node.position[0] ?? 0, node.position[1] ?? 0, node.position[2] ?? 0], ref: ref, "rotation-y": node.rotation ?? 0, children: [_jsx("mesh", { castShadow: true, geometry: clippedGeometry ?? geometry, material: material, name: "dormer-body", receiveShadow: true }), _jsx(DormerWindowAssembly, { dormerToSegment: localToSegment, frameMaterial: frameSideMat, glassMaterial: glassMat, node: node, segment: segment })] }) }));
+};
+// Re-export so consumers (e.g. tests) can reach the gable slot index
+// without importing from `@pascal-app/viewer` directly.
+export { DORMER_GABLE_MATERIAL_INDEX };
+export default DormerRenderer;

package/dist/dormer/schema.d.ts

@@ -0,0 +1,3 @@
+export type { DormerSurfaceMaterialRole, DormerSurfaceMaterialSpec, } from '@pascal-app/core';
+export { DormerNode, getEffectiveDormerSurfaceMaterial } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/dormer/schema.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,UAAU,EAAE,iCAAiC,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/dormer/schema.js

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

package/dist/dormer/tool.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Placement tool for a fresh dormer. The dormer sits UPRIGHT on the
+ * host segment at segment-local `y = 0` (the host wall foot) — the
+ * CSG inside `generateDormerGeometry` carves the dormer against the
+ * host roof's slope, so we don't tilt or lift it here. The ghost is
+ * mounted on the hit segment's world transform (extracted via the
+ * registry) so the user sees exactly where the dormer will land.
+ */
+declare const DormerTool: () => import("react").JSX.Element;
+export default DormerTool;
+//# sourceMappingURL=tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/dormer/tool.tsx"],"names":[],"mappings":"AA6BA;;;;;;;GAOG;AACH,QAAA,MAAM,UAAU,mCA8Df,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/dormer/tool.js

@@ -0,0 +1,69 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { DormerNode, useScene } from '@pascal-app/core';
+import { useViewer } from '@pascal-app/viewer';
+import { useMemo } from 'react';
+import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
+import { dormerDefinition } from './definition';
+import { DormerPlacementGuides } from './placement-guides';
+import DormerPreview from './preview';
+import { useDormerPlacement } from './use-dormer-placement';
+/**
+ * Pick the smallest free integer suffix for a new dormer name so the
+ * scene tree doesn't end up with multiple `Dormer 3`s after deletes.
+ */
+function nextDormerNumber(nodes) {
+    const used = new Set();
+    for (const node of Object.values(nodes)) {
+        if (!node || typeof node !== 'object')
+            continue;
+        const n = node;
+        if (n.type !== 'dormer')
+            continue;
+        const m = n.name?.match(/^Dormer (\d+)$/);
+        if (m?.[1])
+            used.add(Number.parseInt(m[1], 10));
+    }
+    let n = 1;
+    while (used.has(n))
+        n++;
+    return n;
+}
+/**
+ * Placement tool for a fresh dormer. The dormer sits UPRIGHT on the
+ * host segment at segment-local `y = 0` (the host wall foot) — the
+ * CSG inside `generateDormerGeometry` carves the dormer against the
+ * host roof's slope, so we don't tilt or lift it here. The ghost is
+ * mounted on the hit segment's world transform (extracted via the
+ * registry) so the user sees exactly where the dormer will land.
+ */
+const DormerTool = () => {
+    const setSelection = useViewer((s) => s.setSelection);
+    const previewNode = useMemo(() => DormerNode.parse({
+        ...dormerDefinition.defaults(),
+        name: 'Dormer',
+        position: [0, 0, 0],
+        rotation: 0,
+    }), []);
+    const { activeBuildingId, clearPreview, segmentXform, hitSegment, hitLocal, ghostRotation } = useDormerPlacement({
+        onCommit: (hit, rotation) => {
+            const state = useScene.getState();
+            const dormer = DormerNode.parse({
+                ...dormerDefinition.defaults(),
+                name: `Dormer ${nextDormerNumber(state.nodes)}`,
+                roofSegmentId: hit.segment.id,
+                parentId: hit.segment.id,
+                // Anchor at the slope height so the renderer matches the ghost.
+                // The CSG still carves cleanly because it inverts T(position)
+                // when bringing the host into dormer-local.
+                position: [hit.localX, hit.localY, hit.localZ],
+                rotation,
+            });
+            state.createNode(dormer, hit.segment.id);
+            state.dirtyNodes.add(hit.segment.id);
+            setSelection({ selectedIds: [dormer.id] });
+        },
+    });
+    return (_jsxs(_Fragment, { children: [_jsx(RoofAttachmentFallbackPreview, { activeBuildingId: activeBuildingId, ghost: _jsx(DormerPreview, { node: previewNode, invalid: true }), onInvalidTarget: clearPreview }), activeBuildingId && segmentXform && hitLocal && (_jsxs("group", { position: segmentXform.position, quaternion: segmentXform.quaternion, children: [hitSegment && (_jsx(DormerPlacementGuides, { center: hitLocal, depth: previewNode.depth, rotation: ghostRotation, segment: hitSegment, width: previewNode.width })), _jsx("group", { position: hitLocal, children: _jsx("group", { "rotation-y": ghostRotation, children: _jsx(DormerPreview, { node: previewNode }) }) })] }))] }));
+};
+export default DormerTool;

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

@@ -0,0 +1,44 @@
+import { type RoofSegmentNode } from '@pascal-app/core';
+export type DormerSegmentTransform = {
+    position: [number, number, number];
+    quaternion: [number, number, number, number];
+};
+export type DormerPlacementHit = {
+    segment: RoofSegmentNode;
+    localX: number;
+    localY: number;
+    localZ: number;
+};
+/**
+ * Shared placement-tool plumbing for fresh-place and duplicate/move
+ * tools. Owns:
+ *   - cursor → roof-segment hit resolution (delegated to the host
+ *     RoofNode pointer events)
+ *   - building-local segment transform extraction (for ghost mounting)
+ *   - 5cm grid snap + SFX cue
+ *   - keyboard rotate (R / Shift+R, ±15°)
+ *
+ * Does NOT own:
+ *   - the ghost mesh (caller renders `<DormerPreview>`)
+ *   - any node-lifecycle state (caller passes an `onCommit` that
+ *     decides between createNode / updateNode / etc.)
+ *
+ * Returns the segment transform + cursor hit so the caller can mount
+ * the ghost, plus the live ghost rotation (driven by R / Shift+R).
+ */
+export declare function useDormerPlacement(opts: {
+    initialRotation?: number;
+    relativeStart?: {
+        position: [number, number, number];
+        roofSegmentId?: string;
+    };
+    onCommit: (hit: DormerPlacementHit, rotation: number) => void;
+}): {
+    activeBuildingId: string | undefined;
+    clearPreview: () => void;
+    segmentXform: DormerSegmentTransform | null;
+    hitSegment: RoofSegmentNode | null;
+    hitLocal: [number, number, number] | null;
+    ghostRotation: number;
+};
+//# sourceMappingURL=use-dormer-placement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-dormer-placement.d.ts","sourceRoot":"","sources":["../../src/dormer/use-dormer-placement.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AAezB,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAC7C,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,eAAe,CAAA;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,aAAa,CAAC,EAAE;QACd,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;QAClC,aAAa,CAAC,EAAE,MAAM,CAAA;KACvB,CAAA;IACD,QAAQ,EAAE,CAAC,GAAG,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;CAC9D,GAAG;IACF,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,YAAY,EAAE,MAAM,IAAI,CAAA;IACxB,YAAY,EAAE,sBAAsB,GAAG,IAAI,CAAA;IAC3C,UAAU,EAAE,eAAe,GAAG,IAAI,CAAA;IAClC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;IACzC,aAAa,EAAE,MAAM,CAAA;CACtB,CAiJA"}