@pascal-app/nodes 0.1.1

package/dist/dormer/floorplan.js

@@ -0,0 +1,193 @@
+/**
+ * Floor-plan builder for a dormer — a small house-shaped structure that
+ * projects from a roof slope, with its own little roof and a window on the
+ * front face. Seen from above it reads as a `width × depth` footprint plus
+ * its roof's ridge/hip linework, and a line marking the window on the
+ * down-slope (+Z) front face.
+ *
+ * Coordinate frame mirrors the 3D transform stack
+ * (roof → roof-segment → dormer), same as the chimney builder. The
+ * dormer's `position` is segment-local: X = width axis (along the eave),
+ * Z = depth axis (projecting down-slope; +Z is the front/window face).
+ * `rotation` is yaw. Rotations are negated for the floor plan's y-down
+ * convention (see `buildRoofSegmentFloorplan`).
+ *
+ * Per-type roof linework follows the dormer's own roof geometry
+ * (`buildDormerCutShape` in csg-geometry.ts): gable ridge runs along Z,
+ * shed slopes high-at-back (−Z) to low-at-front (+Z), hip ridges along the
+ * longer axis. Gambrel falls back to gable; dutch/mansard to hip — the
+ * same fallbacks the 3D cut uses.
+ */
+export function buildDormerFloorplan(node, ctx) {
+    const segment = ctx.parent;
+    if (segment?.type !== 'roof-segment')
+        return null;
+    const roofId = segment.parentId;
+    const roof = roofId ? ctx.resolve(roofId) : undefined;
+    if (roof?.type !== 'roof')
+        return null;
+    // Compose roof → segment → dormer in plan coords. Each rotation negated
+    // so SVG's y-down CW matches Three.js' top-down CCW.
+    const cosR = Math.cos(-roof.rotation);
+    const sinR = Math.sin(-roof.rotation);
+    const segCx = roof.position[0] + segment.position[0] * cosR - segment.position[2] * sinR;
+    const segCz = roof.position[2] + segment.position[0] * sinR + segment.position[2] * cosR;
+    const segRot = -(roof.rotation + segment.rotation);
+    const cosS = Math.cos(segRot);
+    const sinS = Math.sin(segRot);
+    const cx = segCx + node.position[0] * cosS - node.position[2] * sinS;
+    const cz = segCz + node.position[0] * sinS + node.position[2] * cosS;
+    const rot = -(roof.rotation + segment.rotation + node.rotation);
+    const cos = Math.cos(rot);
+    const sin = Math.sin(rot);
+    const toPlan = (lx, lz) => [
+        cx + lx * cos - lz * sin,
+        cz + lx * sin + lz * cos,
+    ];
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const isSelected = view?.selected ?? false;
+    const isHighlighted = view?.highlighted ?? false;
+    const isHovered = view?.hovered ?? false;
+    const showSelectedChrome = isSelected || isHighlighted;
+    // Reads as a small structure on the roof — neutral grey, accent on
+    // select, light blue on hover.
+    const baseInk = '#52525b';
+    const stroke = showSelectedChrome && palette
+        ? palette.selectedStroke
+        : isHovered && palette
+            ? palette.wallHoverStroke
+            : baseInk;
+    const fill = showSelectedChrome ? '#fed7aa' : '#e4e4e7';
+    const fillOpacity = showSelectedChrome ? 0.55 : 0.6;
+    const lineWidth = showSelectedChrome ? 0.03 : 0.022;
+    const ridgeWidth = showSelectedChrome ? 0.04 : 0.03;
+    const hw = Math.max(node.width, 0.1) / 2;
+    const hd = Math.max(node.depth, 0.1) / 2;
+    const corners = [
+        toPlan(-hw, -hd),
+        toPlan(hw, -hd),
+        toPlan(hw, hd),
+        toPlan(-hw, hd),
+    ];
+    const children = [
+        // Transparent hit-target across the footprint.
+        {
+            kind: 'polygon',
+            points: corners,
+            fill: stroke,
+            fillOpacity: 0,
+            stroke: 'none',
+            strokeWidth: 0,
+            pointerEvents: 'all',
+        },
+        // Body footprint, filled.
+        {
+            kind: 'polygon',
+            points: corners,
+            fill,
+            fillOpacity,
+            stroke,
+            strokeWidth: lineWidth,
+            strokeLinejoin: 'miter',
+            pointerEvents: 'none',
+        },
+    ];
+    const line = (a, b, w) => {
+        const pa = toPlan(a[0], a[1]);
+        const pb = toPlan(b[0], b[1]);
+        children.push({
+            kind: 'line',
+            x1: pa[0],
+            y1: pa[1],
+            x2: pb[0],
+            y2: pb[1],
+            stroke,
+            strokeWidth: w,
+            strokeLinecap: 'round',
+            pointerEvents: 'none',
+        });
+    };
+    // Roof linework per dormer roof type (skipped for flat / zero-height).
+    const type = node.roofType;
+    if (node.roofHeight > 0 && type !== 'flat') {
+        if (type === 'shed') {
+            // Slopes from the high back (−Z) down to the low front (+Z); show a
+            // downslope arrow pointing toward the front.
+            const tail = toPlan(0, -hd * 0.55);
+            const head = toPlan(0, hd * 0.55);
+            const dx = head[0] - tail[0];
+            const dy = head[1] - tail[1];
+            const len = Math.hypot(dx, dy) || 1;
+            const ux = dx / len;
+            const uy = dy / len;
+            const headLen = Math.min(0.25, len * 0.4);
+            const wing = headLen * 0.6;
+            children.push({
+                kind: 'line',
+                x1: tail[0],
+                y1: tail[1],
+                x2: head[0],
+                y2: head[1],
+                stroke,
+                strokeWidth: lineWidth,
+                strokeLinecap: 'round',
+                pointerEvents: 'none',
+            });
+            children.push({
+                kind: 'polyline',
+                points: [
+                    [head[0] - headLen * ux - wing * uy, head[1] - headLen * uy + wing * ux],
+                    [head[0], head[1]],
+                    [head[0] - headLen * ux + wing * uy, head[1] - headLen * uy - wing * ux],
+                ],
+                stroke,
+                strokeWidth: lineWidth,
+                strokeLinecap: 'round',
+                strokeLinejoin: 'round',
+                pointerEvents: 'none',
+            });
+        }
+        else if (type === 'hip' || type === 'dutch' || type === 'mansard') {
+            // Ridge along the longer axis + four hips from the corners (a single
+            // apex when square). Mirrors the dormer cut's pyramid/hip.
+            if (Math.abs(hw - hd) < 0.01) {
+                line([-hw, -hd], [0, 0], lineWidth);
+                line([hw, -hd], [0, 0], lineWidth);
+                line([hw, hd], [0, 0], lineWidth);
+                line([-hw, hd], [0, 0], lineWidth);
+            }
+            else if (hd >= hw) {
+                const rl = hd - hw; // ridge along Z
+                line([0, -rl], [0, rl], ridgeWidth);
+                line([-hw, hd], [0, rl], lineWidth);
+                line([hw, hd], [0, rl], lineWidth);
+                line([-hw, -hd], [0, -rl], lineWidth);
+                line([hw, -hd], [0, -rl], lineWidth);
+            }
+            else {
+                const rl = hw - hd; // ridge along X
+                line([-rl, 0], [rl, 0], ridgeWidth);
+                line([-hw, -hd], [-rl, 0], lineWidth);
+                line([-hw, hd], [-rl, 0], lineWidth);
+                line([hw, -hd], [rl, 0], lineWidth);
+                line([hw, hd], [rl, 0], lineWidth);
+            }
+        }
+        else {
+            // Gable (and gambrel fallback): ridge runs front-to-back along Z.
+            line([0, -hd], [0, hd], ridgeWidth);
+        }
+    }
+    // Window on the +Z (front) face — a line just inside the front edge,
+    // spanning the window width centred at its X offset. Marks the glazing
+    // and which way the dormer faces.
+    const ww = node.windowWidth ?? 0;
+    if (ww > 0.01) {
+        const halfWin = Math.min(ww, node.width) / 2;
+        const center = Math.max(-hw + halfWin, Math.min(hw - halfWin, node.windowOffsetX ?? 0));
+        const inset = Math.min(hd * 0.2, 0.08);
+        line([center - halfWin, hd - inset], [center + halfWin, hd - inset], lineWidth);
+    }
+    return { kind: 'group', children };
+}

package/dist/dormer/geometry.d.ts

@@ -0,0 +1,42 @@
+import type { DormerNode } from '@pascal-app/core';
+import * as THREE from 'three';
+/**
+ * Grid-snap step (metres) applied to the world cursor position while a
+ * dormer placement / move ghost is in flight. Shared by both tools so
+ * the audible snap and the committed position step stay in lockstep.
+ */
+export declare const DORMER_PLACEMENT_SNAP_M = 0.05;
+/**
+ * Rotation step (radians) used by the keyboard rotate shortcuts (R /
+ * Shift+R) while a dormer placement / move ghost is in flight. 15° —
+ * lets the user reach the 90° cardinals in six taps and the 45°
+ * diagonals in three.
+ */
+export declare const DORMER_PLACEMENT_ROTATION_STEP: number;
+/**
+ * Lightweight silhouette geometry used by the placement / move-tool
+ * ghost preview only. Renders the dormer as an extruded pentagon
+ * (rectangle body + triangular gable) dropped by `wallSkirtHeight` below
+ * the anchor so the cursor sits at the floor of the dormer the way the
+ * committed CSG geometry does.
+ *
+ * For `roofType === 'flat'` (or `roofHeight === 0`) the gable apex is
+ * skipped and the shape collapses to a rectangle. Other roof types use
+ * the gable approximation — exact per-type silhouettes are a future
+ * improvement.
+ *
+ * Kept self-contained (no `@pascal-app/viewer` imports) so the geometry
+ * test doesn't drag in the CSG / BVH module graph, which fails to load
+ * outside of a browser/WebGL context. The viewer has its own
+ * `buildDormerFallbackGeometry` that mirrors this shape — used both as
+ * the CSG fallback when boolean ops fail and as the live-drag preview
+ * in the dormer renderer.
+ */
+export declare function buildDormerGhostGeometry(node: DormerNode): THREE.BufferGeometry;
+/**
+ * Inspector helper: which window-shape sub-controls to surface for the
+ * current dormer.
+ */
+export declare function dormerSupportsArch(node: DormerNode): boolean;
+export declare function dormerSupportsCornerRadii(node: DormerNode): boolean;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/dormer/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAA;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,QAAuB,CAAA;AAElE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,KAAK,CAAC,cAAc,CAoB/E;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAE5D;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAEnE"}

package/dist/dormer/geometry.js

@@ -0,0 +1,63 @@
+import * as THREE from 'three';
+/**
+ * Grid-snap step (metres) applied to the world cursor position while a
+ * dormer placement / move ghost is in flight. Shared by both tools so
+ * the audible snap and the committed position step stay in lockstep.
+ */
+export const DORMER_PLACEMENT_SNAP_M = 0.05;
+/**
+ * Rotation step (radians) used by the keyboard rotate shortcuts (R /
+ * Shift+R) while a dormer placement / move ghost is in flight. 15° —
+ * lets the user reach the 90° cardinals in six taps and the 45°
+ * diagonals in three.
+ */
+export const DORMER_PLACEMENT_ROTATION_STEP = (15 * Math.PI) / 180;
+/**
+ * Lightweight silhouette geometry used by the placement / move-tool
+ * ghost preview only. Renders the dormer as an extruded pentagon
+ * (rectangle body + triangular gable) dropped by `wallSkirtHeight` below
+ * the anchor so the cursor sits at the floor of the dormer the way the
+ * committed CSG geometry does.
+ *
+ * For `roofType === 'flat'` (or `roofHeight === 0`) the gable apex is
+ * skipped and the shape collapses to a rectangle. Other roof types use
+ * the gable approximation — exact per-type silhouettes are a future
+ * improvement.
+ *
+ * Kept self-contained (no `@pascal-app/viewer` imports) so the geometry
+ * test doesn't drag in the CSG / BVH module graph, which fails to load
+ * outside of a browser/WebGL context. The viewer has its own
+ * `buildDormerFallbackGeometry` that mirrors this shape — used both as
+ * the CSG fallback when boolean ops fail and as the live-drag preview
+ * in the dormer renderer.
+ */
+export function buildDormerGhostGeometry(node) {
+    const w = Math.max(0.05, node.width);
+    const wallH = Math.max(0.05, node.height);
+    const roofH = Math.max(0, node.roofHeight);
+    const d = Math.max(0.05, node.depth);
+    const skirt = Math.max(0.05, node.wallSkirtHeight);
+    const hw = w / 2;
+    const isFlat = node.roofType === 'flat' || roofH === 0;
+    const shape = new THREE.Shape();
+    shape.moveTo(-hw, -skirt);
+    shape.lineTo(hw, -skirt);
+    shape.lineTo(hw, wallH);
+    if (!isFlat)
+        shape.lineTo(0, wallH + roofH);
+    shape.lineTo(-hw, wallH);
+    shape.closePath();
+    const geo = new THREE.ExtrudeGeometry(shape, { depth: d, bevelEnabled: false });
+    geo.translate(0, 0, -d / 2);
+    return geo;
+}
+/**
+ * Inspector helper: which window-shape sub-controls to surface for the
+ * current dormer.
+ */
+export function dormerSupportsArch(node) {
+    return node.windowShape === 'arch';
+}
+export function dormerSupportsCornerRadii(node) {
+    return node.windowShape === 'rounded';
+}

package/dist/dormer/index.d.ts

@@ -0,0 +1,5 @@
+export { dormerDefinition } from './definition';
+export { buildDormerGhostGeometry, dormerSupportsArch, dormerSupportsCornerRadii, } from './geometry';
+export type { DormerSurfaceMaterialRole, DormerSurfaceMaterialSpec, } from './schema';
+export { DormerNode, getEffectiveDormerSurfaceMaterial } from './schema';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dormer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAClB,yBAAyB,GAC1B,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,UAAU,EAAE,iCAAiC,EAAE,MAAM,UAAU,CAAA"}

package/dist/dormer/index.js

@@ -0,0 +1,3 @@
+export { dormerDefinition } from './definition';
+export { buildDormerGhostGeometry, dormerSupportsArch, dormerSupportsCornerRadii, } from './geometry';
+export { DormerNode, getEffectiveDormerSurfaceMaterial } from './schema';

package/dist/dormer/move-tool.d.ts

@@ -0,0 +1,16 @@
+import { type DormerNode } from '@pascal-app/core';
+/**
+ * Drag-to-place tool for dormer duplicate / move. Receives the moving
+ * node (a clone with `id` stripped + `metadata.isNew = true` after a
+ * Duplicate action) via `node` prop, shows the same ghost preview as
+ * placement, and on click commits the cloned dormer to the hit segment.
+ *
+ * On cancel, a duplicate clone is deleted and an existing dormer is
+ * restored to its original segment + position. Mounted via
+ * `def.affordanceTools.move`.
+ */
+declare const MoveDormerTool: ({ node }: {
+    node: DormerNode;
+}) => import("react").JSX.Element | null;
+export default MoveDormerTool;
+//# sourceMappingURL=move-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/dormer/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAKhB,MAAM,kBAAkB,CAAA;AAQzB;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,uCAkJrD,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/dormer/move-tool.js

@@ -0,0 +1,136 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DormerNode as DormerNodeSchema, sceneRegistry, useScene, } from '@pascal-app/core';
+import { useEditor } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo } from 'react';
+import { DormerPlacementGuides } from './placement-guides';
+import DormerPreview from './preview';
+import { useDormerPlacement } from './use-dormer-placement';
+/**
+ * Drag-to-place tool for dormer duplicate / move. Receives the moving
+ * node (a clone with `id` stripped + `metadata.isNew = true` after a
+ * Duplicate action) via `node` prop, shows the same ghost preview as
+ * placement, and on click commits the cloned dormer to the hit segment.
+ *
+ * On cancel, a duplicate clone is deleted and an existing dormer is
+ * restored to its original segment + position. Mounted via
+ * `def.affordanceTools.move`.
+ */
+const MoveDormerTool = ({ node }) => {
+    const setSelection = useViewer((s) => s.setSelection);
+    const setMovingNode = useEditor((s) => s.setMovingNode);
+    // Ghost data — same as the moving clone but pinned to position[0,0,0]
+    // (the outer groups place it on the roof). Reparse so Zod fills any
+    // defaults missing from the clone.
+    const previewNode = useMemo(() => {
+        const { id: _id, ...rest } = node;
+        return DormerNodeSchema.parse({
+            ...rest,
+            position: [0, 0, 0],
+            rotation: 0,
+        });
+    }, [node]);
+    // Hide the moving dormer while dragging. Restored in cleanup or on
+    // commit. We also mark metadata.isTransient so any other consumer
+    // (e.g. the inspector) can short-circuit.
+    const meta = typeof node.metadata === 'object' && node.metadata !== null
+        ? node.metadata
+        : {};
+    const isNew = !!meta.isNew;
+    const originalRotation = node.rotation ?? 0;
+    const originalMetadata = node.metadata;
+    // biome-ignore lint/correctness/useExhaustiveDependencies: capture-on-mount; meta is intentionally not re-read on changes.
+    useEffect(() => {
+        if (!isNew) {
+            useScene.getState().updateNode(node.id, {
+                metadata: { ...meta, isTransient: true },
+            });
+        }
+        const dormerObj = sceneRegistry.nodes.get(node.id);
+        const prevVisible = dormerObj?.visible;
+        if (dormerObj)
+            dormerObj.visible = false;
+        return () => {
+            // Restore visibility + metadata if the move was cancelled.
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = prevVisible ?? true;
+            if (!isNew) {
+                useScene.getState().updateNode(node.id, {
+                    metadata: originalMetadata,
+                });
+            }
+        };
+    }, [node.id, isNew]);
+    const { activeBuildingId, segmentXform, hitSegment, hitLocal, ghostRotation } = useDormerPlacement({
+        initialRotation: originalRotation,
+        relativeStart: {
+            position: [...node.position],
+            roofSegmentId: node.roofSegmentId,
+        },
+        onCommit: (hit, rotation) => {
+            const state = useScene.getState();
+            // Strip the `isNew` / `isTransient` flags — only used to mark a
+            // clone or in-flight move that hasn't been committed yet.
+            const cleanedMeta = (() => {
+                const m = node.metadata && typeof node.metadata === 'object' && !Array.isArray(node.metadata)
+                    ? node.metadata
+                    : {};
+                const { isNew: _isNew, isTransient: _isTransient, ...rest } = m;
+                return Object.keys(rest).length > 0 ? rest : undefined;
+            })();
+            if (isNew || !node.id) {
+                const { id: _id, ...rest } = node;
+                const committed = DormerNodeSchema.parse({
+                    ...rest,
+                    roofSegmentId: hit.segment.id,
+                    parentId: hit.segment.id,
+                    position: [hit.localX, hit.localY, hit.localZ],
+                    rotation,
+                    metadata: cleanedMeta,
+                });
+                state.createNode(committed, hit.segment.id);
+                state.dirtyNodes.add(hit.segment.id);
+                setSelection({ selectedIds: [committed.id] });
+            }
+            else {
+                const prevSegmentId = node.roofSegmentId;
+                state.updateNode(node.id, {
+                    roofSegmentId: hit.segment.id,
+                    parentId: hit.segment.id,
+                    position: [hit.localX, hit.localY, hit.localZ],
+                    rotation,
+                    metadata: cleanedMeta,
+                });
+                if (prevSegmentId)
+                    state.dirtyNodes.add(prevSegmentId);
+                state.dirtyNodes.add(hit.segment.id);
+                // Unlist from previous segment's children and add to the new one.
+                if (prevSegmentId && prevSegmentId !== hit.segment.id) {
+                    const prevSeg = state.nodes[prevSegmentId];
+                    if (prevSeg) {
+                        state.updateNode(prevSegmentId, {
+                            children: (prevSeg.children ?? []).filter((id) => id !== node.id),
+                        });
+                    }
+                    const newSeg = state.nodes[hit.segment.id];
+                    if (newSeg && !(newSeg.children ?? []).includes(node.id)) {
+                        state.updateNode(hit.segment.id, {
+                            children: [...(newSeg.children ?? []), node.id],
+                        });
+                    }
+                }
+                setSelection({ selectedIds: [node.id] });
+            }
+            const dormerObj = sceneRegistry.nodes.get(node.id);
+            if (dormerObj)
+                dormerObj.visible = true;
+            setMovingNode(null);
+        },
+    });
+    if (!activeBuildingId || !segmentXform || !hitLocal)
+        return null;
+    return (_jsxs("group", { position: segmentXform.position, quaternion: segmentXform.quaternion, children: [hitSegment && (_jsx(DormerPlacementGuides, { center: hitLocal, depth: previewNode.depth, movingId: node.id, rotation: ghostRotation, segment: hitSegment, width: previewNode.width })), _jsx("group", { position: hitLocal, children: _jsx("group", { "rotation-y": ghostRotation, children: _jsx(DormerPreview, { node: previewNode }) }) })] }));
+};
+export default MoveDormerTool;

package/dist/dormer/paint.d.ts

@@ -0,0 +1,24 @@
+import type { DormerNode, DormerSurfaceMaterialRole, MaterialSchema, PaintCapability } from '@pascal-app/core';
+/**
+ * Resolve a dormer face click to its logical surface role.
+ *
+ * The dormer body mesh has 5 material slots (see
+ * `csg-geometry.ts:generateDormerGeometry`):
+ *   0 = wall (rectangular wall)
+ *   1 = side (deck along the slope)
+ *   2 = interior — paint as wall
+ *   3 = top   (roof shingle)
+ *   4 = gable triangle — paint as wall
+ *
+ * Window-frame meshes are not in the body mesh; they're routed to
+ * 'side' separately by the editor when the click lands on them.
+ */
+export declare function resolveDormerRole(materialIndex: number | null): DormerSurfaceMaterialRole;
+export declare function buildDormerMaterialPatch(role: DormerSurfaceMaterialRole, material: MaterialSchema | undefined, materialPreset: string | undefined): Partial<DormerNode>;
+/**
+ * Capability binding for the dormer kind. The editor's
+ * selection-manager invokes these in place of the legacy
+ * `if (node.type === 'dormer') { ... }` arm.
+ */
+export declare const dormerPaint: PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/dormer/paint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,yBAAyB,EACzB,cAAc,EACd,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAKzB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,yBAAyB,CAIzF;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,yBAAyB,EAC/B,QAAQ,EAAE,cAAc,GAAG,SAAS,EACpC,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,OAAO,CAAC,UAAU,CAAC,CAQrB;AAwDD;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,eAgBzB,CAAA"}

package/dist/dormer/paint.js

@@ -0,0 +1,103 @@
+import { getEffectiveDormerSurfaceMaterial } from '@pascal-app/core';
+import { createMaterial, createMaterialFromPresetRef } from '@pascal-app/viewer';
+/**
+ * Resolve a dormer face click to its logical surface role.
+ *
+ * The dormer body mesh has 5 material slots (see
+ * `csg-geometry.ts:generateDormerGeometry`):
+ *   0 = wall (rectangular wall)
+ *   1 = side (deck along the slope)
+ *   2 = interior — paint as wall
+ *   3 = top   (roof shingle)
+ *   4 = gable triangle — paint as wall
+ *
+ * Window-frame meshes are not in the body mesh; they're routed to
+ * 'side' separately by the editor when the click lands on them.
+ */
+export function resolveDormerRole(materialIndex) {
+    if (materialIndex === 3)
+        return 'top';
+    if (materialIndex === 1)
+        return 'side';
+    return 'wall';
+}
+export function buildDormerMaterialPatch(role, material, materialPreset) {
+    if (role === 'top') {
+        return { topMaterial: material, topMaterialPreset: materialPreset };
+    }
+    if (role === 'side') {
+        return { sideMaterial: material, sideMaterialPreset: materialPreset };
+    }
+    return { wallMaterial: material, wallMaterialPreset: materialPreset };
+}
+function buildPreviewMaterial(material, materialPreset) {
+    if (materialPreset) {
+        return createMaterialFromPresetRef(materialPreset);
+    }
+    if (material) {
+        return createMaterial(material);
+    }
+    return null;
+}
+/**
+ * Apply a preview material to the dormer's `dormer-body` mesh at the
+ * slots that map to `role`:
+ *   role='wall' → slots [0, 2, 4]
+ *   role='side' → slot  [1]
+ *   role='top'  → slot  [3]
+ */
+function applyDormerPreview(role, previewMaterial, root) {
+    const slotsToPaint = (() => {
+        if (role === 'top')
+            return [3];
+        if (role === 'side')
+            return [1];
+        return [0, 2, 4];
+    })();
+    const restores = [];
+    root.traverse((object) => {
+        const mesh = object;
+        if (!mesh.isMesh)
+            return;
+        if (mesh.name !== 'dormer-body')
+            return;
+        const current = mesh.material;
+        if (!Array.isArray(current))
+            return;
+        const previousArray = [...current];
+        const nextArray = [...current];
+        for (const idx of slotsToPaint) {
+            if (current[idx])
+                nextArray[idx] = previewMaterial;
+        }
+        mesh.material = nextArray;
+        restores.push(() => {
+            mesh.material = previousArray;
+        });
+    });
+    if (restores.length === 0)
+        return null;
+    return () => {
+        for (let i = restores.length - 1; i >= 0; i -= 1)
+            restores[i]?.();
+    };
+}
+/**
+ * Capability binding for the dormer kind. The editor's
+ * selection-manager invokes these in place of the legacy
+ * `if (node.type === 'dormer') { ... }` arm.
+ */
+export const dormerPaint = {
+    resolveRole: ({ materialIndex }) => resolveDormerRole(materialIndex),
+    buildPatch: ({ role, material, materialPreset }) => buildDormerMaterialPatch(role, material, materialPreset),
+    applyPreview: ({ role, material, materialPreset, root }) => {
+        const previewMaterial = buildPreviewMaterial(material, materialPreset);
+        if (!previewMaterial)
+            return null;
+        return applyDormerPreview(role, previewMaterial, root);
+    },
+    getEffectiveMaterial: ({ node, role }) => {
+        const spec = getEffectiveDormerSurfaceMaterial(node, role);
+        return { material: spec.material, materialPreset: spec.materialPreset };
+    },
+};

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

@@ -0,0 +1,10 @@
+/**
+ * Move / Duplicate / Delete buttons at the bottom of the dormer
+ * inspector. Pure presentation — owners pass the three handlers.
+ */
+export declare function DormerActionsSection({ onMove, onDuplicate, onDelete, }: {
+    onMove: () => void;
+    onDuplicate: () => void;
+    onDelete: () => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=panel-actions-section.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel-actions-section.d.ts","sourceRoot":"","sources":["../../src/dormer/panel-actions-section.tsx"],"names":[],"mappings":"AAKA;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,MAAM,EACN,WAAW,EACX,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,QAAQ,EAAE,MAAM,IAAI,CAAA;CACrB,+BAmBA"}

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

@@ -0,0 +1,11 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ActionButton, ActionGroup, PanelSection } from '@pascal-app/editor';
+import { Copy, Move, Trash2 } from 'lucide-react';
+/**
+ * Move / Duplicate / Delete buttons at the bottom of the dormer
+ * inspector. Pure presentation — owners pass the three handlers.
+ */
+export function DormerActionsSection({ onMove, onDuplicate, onDelete, }) {
+    return (_jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: onMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: onDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-400" }), label: "Delete", onClick: onDelete })] }) }));
+}

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

@@ -0,0 +1,17 @@
+import { type DormerNode, type RoofNode, type RoofSegmentNode } from '@pascal-app/core';
+/**
+ * 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 declare function DormerPositionSection({ node, segment, roof, selectedId, previewProp, commitProp, }: {
+    node: DormerNode;
+    segment: RoofSegmentNode | undefined;
+    roof: RoofNode | undefined;
+    selectedId: string;
+    previewProp: (updates: Partial<DormerNode>) => void;
+    commitProp: (updates: Partial<DormerNode>) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=panel-position-section.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel-position-section.d.ts","sourceRoot":"","sources":["../../src/dormer/panel-position-section.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AAKzB;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,IAAI,EACJ,OAAO,EACP,IAAI,EACJ,UAAU,EACV,WAAW,EACX,UAAU,GACX,EAAE;IACD,IAAI,EAAE,UAAU,CAAA;IAChB,OAAO,EAAE,eAAe,GAAG,SAAS,CAAA;IACpC,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAA;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,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;CACnD,+BA+LA"}