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

package/dist/dormer/definition.js

@@ -1,5 +1,5 @@
 import { DormerNode as DormerNodeSchema, } from '@pascal-app/core';
-import { buildDormerRoofCut, getDormerExposedFaces } from './csg-geometry';
+import { buildDormerRoofCut } from './csg-geometry';
 import { buildDormerFloorplan } from './floorplan';
 import { dormerPaint } from './paint';
 import { dormerParametrics } from './parametrics';
@@ -16,21 +16,6 @@ const MIN_ROOF_HEIGHT = 0;
 const MAX_ROOF_HEIGHT = 2;
 const MIN_SKIRT = 0.2;
 const MAX_SKIRT = 6;
-// Window-handle constants. The window opening is parametric geometry
-// on the dormer's +Z gable face; chevrons sit just outside its rim
-// with a small forward Z offset so they pop in front of the wall plane
-// instead of z-fighting with the frame bars.
-const WINDOW_SIDE_HANDLE_OFFSET = 0.15;
-const WINDOW_HEIGHT_HANDLE_OFFSET = 0.15;
-const WINDOW_FACE_Z_OFFSET = 0.05;
-// The four window-edge arrows latch behind a cube at the window center;
-// they stay hidden until the user clicks that cube to open the group.
-const WINDOW_LATCH_GROUP = 'dormer-window';
-// Lower clamp for window dims matches the geometry's internal clamp
-// in `getDormerSkirtWindowDims` (0.1m). Upper clamps depend on the
-// dormer dimensions and are resolved per-handle via the function form
-// of `max`.
-const MIN_WINDOW_DIM = 0.1;
 // Clamp used for handle Y placement so side chevrons stay reachable on
 // dormers whose wall is flat (`height ≈ 0`). The dormer body is
 // `height + roofHeight` tall; if that collapses too, the side arrows
@@ -73,8 +58,7 @@ function dormerWidthHandle(side) {
         // arrows become visible during selection without us reaching for
         // `portal: 'grandparent'` — which trips the same "Color target has
         // no corresponding fragment stage output" WebGPU pipeline error
-        // chimney already documents (likely an MRT interaction with the
-        // window-assembly's transparent glazing meshes).
+        // chimney already documents.
         min: MIN_DIM,
         currentValue: (n) => n.width,
         apply: (initial, newWidth) => {
@@ -234,158 +218,6 @@ function dormerRotateHandle() {
         },
     };
 }
-// Window-center Y in dormer-local frame. The schema stores
-// `windowOffsetY` as the bottom-relative offset of the window center
-// from the bottom of the skirt; the geometry then maps it to
-// `centerY = -(skirtH / 2) + offsetY`. We mirror that here so handle
-// placements line up with what the inspector + window-assembly use.
-function getWindowCenterY(n) {
-    return -(n.wallSkirtHeight / 2) + n.windowOffsetY;
-}
-// Sign of the dormer-local Z direction where the visible window face
-// sits. The dormer renders the window on both +Z (front) and -Z (back)
-// gable faces, but only whichever face actually pokes above the host
-// roof slope is exposed — `getDormerExposedFaces` is the source of
-// truth there. The in-world handles need to attach to that exposed
-// face so the user is editing the window they can see; as the dormer
-// drags across the ridge, the exposed face flips and the chevrons
-// follow.
-//
-// Preference order when both faces are exposed (e.g. a tall gable that
-// pokes above the roof on both ends): keep handles on +Z so the
-// affordance stays put visually instead of flipping when the slope
-// math grazes the threshold from the other side. When neither face is
-// exposed (degenerate — wall buried on both sides), fall back to +Z so
-// the placement still produces a valid vector; the chevrons are just
-// not useful there.
-function getExposedFaceZSign(n, sceneApi) {
-    if (!n.roofSegmentId)
-        return 1;
-    const segment = sceneApi.get(n.roofSegmentId);
-    if (!segment)
-        return 1;
-    const exposed = getDormerExposedFaces(n, segment);
-    if (exposed.front)
-        return 1;
-    if (exposed.back)
-        return -1;
-    return 1;
-}
-// Window-width chevron on the +X (right) or -X (left) edge of the
-// opening. Asymmetric: dragging one arrow grows the window outward
-// from its own edge while the opposite edge stays put. The framework
-// only knows about the scalar `windowWidth`; we re-emit `windowOffsetX`
-// in `apply` so the anchored edge stays at the same X in dormer-local.
-// Placement sits on the dormer's +Z gable face, where the window opens.
-function dormerWindowWidthHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        // Stand the blade up into the gable face so it reads flat-on like the
-        // top/bottom window-height arrows instead of edge-on.
-        faceNormal: true,
-        // Hidden until the user clicks the window-center latch cube.
-        latchGroup: WINDOW_LATCH_GROUP,
-        anchor: side === 'right' ? 'min' : 'max',
-        min: MIN_WINDOW_DIM,
-        // Cap at the dormer's window field — keep a 0.1m gap on each side
-        // to match the geometry's interior clamp (`maxW = width - 0.1`).
-        max: (n) => Math.max(MIN_WINDOW_DIM, n.width - 0.1),
-        currentValue: (n) => n.windowWidth,
-        apply: (initial, newWidth) => {
-            // Anchored edge stays fixed: anchor X = initial.windowOffsetX -
-            // sign * initial.windowWidth/2. New center = anchor + sign *
-            // newWidth/2 → new windowOffsetX.
-            const anchorX = initial.windowOffsetX - sign * (initial.windowWidth / 2);
-            const newOffsetX = anchorX + sign * (newWidth / 2);
-            return {
-                windowWidth: newWidth,
-                windowOffsetX: newOffsetX,
-            };
-        },
-        placement: {
-            position: (n, sceneApi) => {
-                const faceSign = getExposedFaceZSign(n, sceneApi);
-                return [
-                    n.windowOffsetX + sign * (n.windowWidth / 2 + WINDOW_SIDE_HANDLE_OFFSET),
-                    getWindowCenterY(n),
-                    faceSign * (n.depth / 2 + WINDOW_FACE_Z_OFFSET),
-                ];
-            },
-            // Left chevron points -X; right points +X. LinearArrow doesn't
-            // auto-orient axis 'x' — descriptor handles the flip.
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-    };
-}
-// Window-height chevron on the +Y (top) or -Y (bottom) edge of the
-// opening. Same asymmetric pattern as the width handle, projected onto
-// the Y axis. The schema stores the window's vertical position as
-// `windowOffsetY` (distance from the BOTTOM of the skirt to the window
-// CENTER), not as a centerY in dormer-local — so `apply` translates
-// back through that mapping when it re-emits the offset.
-function dormerWindowHeightHandle(side) {
-    const sign = side === 'top' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        // Hidden until the user clicks the window-center latch cube.
-        latchGroup: WINDOW_LATCH_GROUP,
-        // 'min' = bottom edge anchored (top arrow grows the top edge up).
-        // 'max' = top edge anchored (bottom arrow drops the bottom edge).
-        anchor: side === 'top' ? 'min' : 'max',
-        min: MIN_WINDOW_DIM,
-        // Cap at the skirt with a 0.1m interior margin — matches
-        // `maxH = skirtH - 0.1` from `getDormerSkirtWindowDims`.
-        max: (n) => Math.max(MIN_WINDOW_DIM, n.wallSkirtHeight - 0.1),
-        currentValue: (n) => n.windowHeight,
-        apply: (initial, newHeight) => {
-            // Compute the anchored edge in dormer-local Y, derive the new
-            // centerY, then map back to schema-form `windowOffsetY`.
-            const initialCenterY = -(initial.wallSkirtHeight / 2) + initial.windowOffsetY;
-            const anchorY = initialCenterY - sign * (initial.windowHeight / 2);
-            const newCenterY = anchorY + sign * (newHeight / 2);
-            const newOffsetY = newCenterY + initial.wallSkirtHeight / 2;
-            return {
-                windowHeight: newHeight,
-                windowOffsetY: newOffsetY,
-            };
-        },
-        placement: {
-            position: (n, sceneApi) => {
-                const faceSign = getExposedFaceZSign(n, sceneApi);
-                return [
-                    n.windowOffsetX,
-                    getWindowCenterY(n) + sign * (n.windowHeight / 2 + WINDOW_HEIGHT_HANDLE_OFFSET),
-                    faceSign * (n.depth / 2 + WINDOW_FACE_Z_OFFSET),
-                ];
-            },
-        },
-    };
-}
-// Window-center latch cube. Sits at the window center on the exposed
-// gable face; clicking it reveals / hides the four window edge arrows
-// (width L/R + height top/bottom) tagged with `WINDOW_LATCH_GROUP`.
-// Mirrors the duct-fitting selection cube but driven by the shared
-// latch descriptor so the dense window cluster stays collapsed behind
-// one grip until the user opts in.
-function dormerWindowLatchHandle() {
-    return {
-        kind: 'latch',
-        group: WINDOW_LATCH_GROUP,
-        placement: {
-            position: (n, sceneApi) => {
-                const faceSign = getExposedFaceZSign(n, sceneApi);
-                return [
-                    n.windowOffsetX,
-                    getWindowCenterY(n),
-                    faceSign * (n.depth / 2 + WINDOW_FACE_Z_OFFSET),
-                ];
-            },
-        },
-    };
-}
 const dormerHandles = [
     dormerWidthHandle('right'),
     dormerWidthHandle('left'),
@@ -393,11 +225,6 @@ const dormerHandles = [
     dormerDepthHandle('back'),
     dormerWallHeightHandle(),
     dormerRotateHandle(),
-    dormerWindowLatchHandle(),
-    dormerWindowWidthHandle('right'),
-    dormerWindowWidthHandle('left'),
-    dormerWindowHeightHandle('top'),
-    dormerWindowHeightHandle('bottom'),
     // The wall-skirt (downward chevron), roof-height (peak chevron), and
     // the asymmetric front/back depth split stay out for now. Re-adding
     // any of them previously fired the "Color target has no
@@ -406,30 +233,22 @@ const dormerHandles = [
     // extras — only reproducible while `portal: 'grandparent'` was set,
     // which we no longer rely on (RoofEditSystem reveals the wrapper
     // instead). The shapes themselves are valid; if the count budget
-    // turns out to also be sensitive without grandparent portal, drop
-    // the window handles first since the inspector covers them too.
+    // turns out to also be sensitive without grandparent portal, keep
+    // the current compact set.
     // dormerWallSkirtHandle(),
     // dormerRoofHeightHandle(),
 ];
 /**
  * Dormer — a small house-shaped protrusion sitting on top of a roof
- * segment. The window opening is inlined into the dormer's schema
- * (window* fields drive parametric geometry on the front face), not
- * a hosted child node — so `relations.hosts` stays unset.
+ * segment. Windows are hosted child nodes; the legacy window* fields remain
+ * in the schema only so scene migration can preserve older dormers.
  *
- * **Scope of this port — stub.** Schema is complete (every field from
- * the archive, including the four per-surface material slots and the
- * full window-opening field set). Geometry renders a simple house
- * silhouette (box body + triangular gable roof) for all `roofType`
- * variants — the archive's variant-specific dormer roof shapes,
- * window opening + frame, sill, and the CSG trim where the dormer
- * meets the host roof are deferred. Per-surface paints (`topMaterial`,
- * `sideMaterial`, `wallMaterial`) resolve via the shared helper from
- * core but only roof / wall surfaces are emitted by the stub geometry.
+ * The renderer cuts each hosted window from the dormer shell and mounts
+ * the regular WindowNode renderer in the selected wall-face frame.
  */
 export const dormerDefinition = {
     kind: 'dormer',
-    schemaVersion: 1,
+    schemaVersion: 4,
     schema: DormerNode,
     category: 'structure',
     surfaceRole: 'roof',
@@ -443,7 +262,9 @@ export const dormerDefinition = {
     },
     capabilities: {
         selectable: { hitVolume: 'bbox' },
-        duplicable: true,
+        // Dormers own their WindowNode children. Duplicate the complete subtree
+        // so the copied dormer never aliases windows from the source dormer.
+        duplicable: { subtree: true },
         deletable: true,
         // Mounts on a roof segment via `roofSegmentId`. Dirty marks
         // cascade to the host segment's parent roof so its merged shell
@@ -458,6 +279,10 @@ export const dormerDefinition = {
         // arm.
         paint: dormerPaint,
     },
+    relations: {
+        hosts: ['window'],
+        cascadeDelete: 'descendants',
+    },
     affordanceTools: {
         // Drag-to-place tool for duplicate + move. Reuses the placement
         // ghost preview but seeds it from the moving (cloned) node so the
@@ -482,11 +307,11 @@ export const dormerDefinition = {
     presentation: {
         label: 'Dormer',
         description: 'House-shaped protrusion on a roof segment.',
-        icon: { kind: 'url', src: '/icons/roof.webp' },
+        icon: { kind: 'url', src: '/icons/dormer.webp' },
         paletteSection: 'structure',
         paletteOrder: 125,
     },
     mcp: {
-        description: 'A dormer on a roof segment. Box body + gable roof + inlined window opening. Geometry beyond the stub silhouette coming later.',
+        description: 'A dormer on a roof segment. Its windows are hosted WindowNode children.',
     },
 };

package/dist/dormer/floorplan.d.ts

@@ -15,9 +15,9 @@ import type { DormerNode, FloorplanGeometry, GeometryContext } from '@pascal-app
  *
  * 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.
+ * shed arrows follow the configured high-to-low direction, and hip ridges
+ * run along the longer axis. Gambrel falls back to gable; dutch/mansard to
+ * hip — the same fallbacks the 3D cut uses.
  */
 export declare function buildDormerFloorplan(node: DormerNode, ctx: GeometryContext): FloorplanGeometry | null;
 //# sourceMappingURL=floorplan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/dormer/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,UAAU,EACV,iBAAiB,EAEjB,eAAe,EAGhB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAmL1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/dormer/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,UAAU,EACV,iBAAiB,EAEjB,eAAe,EAGhB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAuK1B"}

package/dist/dormer/floorplan.js

@@ -14,9 +14,9 @@
  *
  * 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.
+ * shed arrows follow the configured high-to-low direction, and hip ridges
+ * run 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;
@@ -112,10 +112,9 @@ export function buildDormerFloorplan(node, ctx) {
     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 highZ = node.shedHighSide === 'front' ? hd * 0.55 : -hd * 0.55;
+            const tail = toPlan(0, highZ);
+            const head = toPlan(0, -highZ);
             const dx = head[0] - tail[0];
             const dy = head[1] - tail[1];
             const len = Math.hypot(dx, dy) || 1;
@@ -179,15 +178,5 @@ export function buildDormerFloorplan(node, ctx) {
             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

@@ -1,4 +1,4 @@
-import type { DormerNode } from '@pascal-app/core';
+import { type DormerNode } from '@pascal-app/core';
 import * as THREE from 'three';
 /**
  * Grid-snap step (metres) applied to the world cursor position while a
@@ -13,30 +13,11 @@ export declare const DORMER_PLACEMENT_SNAP_M = 0.05;
  * diagonals in three.
  */
 export declare const DORMER_PLACEMENT_ROTATION_STEP: number;
+export declare function getDormerBodyYaw(node: Pick<DormerNode, 'roofType' | 'shedHighSide'>): 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.
+ * Builds the lightweight placement and live-edit shell from the same
+ * per-type face generator used by committed roof geometry.
  */
+export declare function buildDormerShellGeometry(node: DormerNode): THREE.BufferGeometry;
 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

@@ -1 +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"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/dormer/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAKhB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAA;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,QAAuB,CAAA;AAElE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,UAAU,GAAG,cAAc,CAAC,GAAG,MAAM,CAG5F;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,KAAK,CAAC,cAAc,CA0D/E;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,KAAK,CAAC,cAAc,CAE/E"}

package/dist/dormer/geometry.js

@@ -1,3 +1,4 @@
+import { getPitchFromActiveRoofHeight, getRoofModuleFaces, getRoofShapeRatios, ROOF_SHAPE_DEFAULTS, } from '@pascal-app/core';
 import * as THREE from 'three';
 /**
  * Grid-snap step (metres) applied to the world cursor position while a
@@ -12,52 +13,74 @@ export const DORMER_PLACEMENT_SNAP_M = 0.05;
  * diagonals in three.
  */
 export const DORMER_PLACEMENT_ROTATION_STEP = (15 * Math.PI) / 180;
+export function getDormerBodyYaw(node) {
+    if (node.roofType !== 'shed')
+        return Math.PI / 2;
+    return node.shedHighSide === 'front' ? Math.PI : 0;
+}
 /**
- * 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.
+ * Builds the lightweight placement and live-edit shell from the same
+ * per-type face generator used by committed roof geometry.
  */
-export function buildDormerGhostGeometry(node) {
+export function buildDormerShellGeometry(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';
+    const skirt = Math.max(0.05, node.wallSkirtHeight ?? 2);
+    const isShed = node.roofType === 'shed';
+    const segW = isShed ? w : d;
+    const segD = isShed ? d : w;
+    const pitch = getPitchFromActiveRoofHeight({
+        roofType: node.roofType,
+        width: segW,
+        depth: segD,
+        roofHeight: roofH,
+    });
+    const faces = getRoofModuleFaces({
+        type: node.roofType,
+        w: segW,
+        d: segD,
+        wh: wallH,
+        rh: roofH,
+        baseY: -skirt,
+        insets: {},
+        baseW: segW,
+        baseD: segD,
+        tanTheta: Math.tan((pitch * Math.PI) / 180),
+        shapeRatios: getRoofShapeRatios(ROOF_SHAPE_DEFAULTS),
+    });
+    const positions = [];
+    const materialGroups = [];
+    for (const face of faces) {
+        if (face.length < 3)
+            continue;
+        const a = new THREE.Vector3(face[0].x, face[0].y, face[0].z);
+        const b = new THREE.Vector3(face[1].x, face[1].y, face[1].z);
+        const c = new THREE.Vector3(face[2].x, face[2].y, face[2].z);
+        const normal = b.clone().sub(a).cross(c.clone().sub(a)).normalize();
+        const start = positions.length / 3;
+        for (let index = 1; index < face.length - 1; index++) {
+            for (const point of [face[0], face[index], face[index + 1]]) {
+                positions.push(point.x, point.y, point.z);
+            }
+        }
+        materialGroups.push({
+            start,
+            count: positions.length / 3 - start,
+            materialIndex: normal.y > 0.01 ? 3 : 0,
+        });
+    }
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    for (const group of materialGroups)
+        geometry.addGroup(group.start, group.count, group.materialIndex);
+    const bodyYaw = getDormerBodyYaw(node);
+    if (bodyYaw !== 0)
+        geometry.rotateY(bodyYaw);
+    geometry.computeVertexNormals();
+    return geometry;
 }
-export function dormerSupportsCornerRadii(node) {
-    return node.windowShape === 'rounded';
+export function buildDormerGhostGeometry(node) {
+    return buildDormerShellGeometry(node);
 }

package/dist/dormer/index.d.ts

@@ -1,5 +1,5 @@
 export { dormerDefinition } from './definition';
-export { buildDormerGhostGeometry, dormerSupportsArch, dormerSupportsCornerRadii, } from './geometry';
+export { buildDormerGhostGeometry } 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

@@ -1 +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"}
+{"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,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AACrD,YAAY,EACV,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,UAAU,EAAE,iCAAiC,EAAE,MAAM,UAAU,CAAA"}

package/dist/dormer/index.js

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

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

@@ -1 +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"}
+{"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,uCA2KrD,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/dormer/move-tool.js

@@ -1,7 +1,7 @@
 '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 { commitFreshPlacementSubtree, useEditor } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo } from 'react';
 import { DormerPlacementGuides } from './placement-guides';
@@ -56,7 +56,13 @@ const MoveDormerTool = ({ node }) => {
             const obj = sceneRegistry.nodes.get(node.id);
             if (obj)
                 obj.visible = prevVisible ?? true;
-            if (!isNew) {
+            if (isNew) {
+                if (node.id && useScene.getState().nodes[node.id]) {
+                    useScene.getState().deleteNode(node.id);
+                }
+                useScene.temporal.getState().resume();
+            }
+            else {
                 useScene.getState().updateNode(node.id, {
                     metadata: originalMetadata,
                 });
@@ -80,7 +86,29 @@ const MoveDormerTool = ({ node }) => {
                 const { isNew: _isNew, isTransient: _isTransient, ...rest } = m;
                 return Object.keys(rest).length > 0 ? rest : undefined;
             })();
-            if (isNew || !node.id) {
+            if (isNew && node.id) {
+                const committedId = commitFreshPlacementSubtree(node.id, {
+                    roofSegmentId: hit.segment.id,
+                    parentId: hit.segment.id,
+                    position: [hit.localX, hit.localY, hit.localZ],
+                    rotation,
+                    metadata: cleanedMeta,
+                    visible: true,
+                });
+                if (!committedId)
+                    return;
+                const committedNode = useScene.getState().nodes[committedId];
+                for (const childId of committedNode?.children ?? []) {
+                    const child = useScene.getState().nodes[childId];
+                    if (child?.type === 'window') {
+                        useScene.getState().updateNode(childId, { dormerId: committedId });
+                    }
+                }
+                state.dirtyNodes.add(hit.segment.id);
+                state.dirtyNodes.add(committedId);
+                setSelection({ selectedIds: [committedId] });
+            }
+            else if (!node.id) {
                 const { id: _id, ...rest } = node;
                 const committed = DormerNodeSchema.parse({
                     ...rest,

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

@@ -141,12 +141,12 @@ export function DormerPositionSection({ node, segment, roof, selectedId, preview
                         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) => {
+                }, onCommit: (newWorldX) => commitWorldPosition(newWorldX, worldZ_now), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: worldX_now }), _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) => {
+                }, onCommit: (newWorldZ) => commitWorldPosition(worldX_now, newWorldZ), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: worldZ_now }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (degrees) => {
                     const newWorldRot = (degrees * Math.PI) / 180;
                     let ancestorWorldY = 0;
                     if (segment) {

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

@@ -0,0 +1,9 @@
+import type { WindowNode } from '@pascal-app/core';
+export declare function DormerWindowsSection({ windows, canAdd, onAdd, onEdit, onMove, }: {
+    windows: WindowNode[];
+    canAdd: boolean;
+    onAdd: () => void;
+    onEdit: (window: WindowNode) => void;
+    onMove: (window: WindowNode) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=panel-windows-section.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel-windows-section.d.ts","sourceRoot":"","sources":["../../src/dormer/panel-windows-section.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAIlD,wBAAgB,oBAAoB,CAAC,EACnC,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,EACN,MAAM,GACP,EAAE;IACD,OAAO,EAAE,UAAU,EAAE,CAAA;IACrB,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,MAAM,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAA;IACpC,MAAM,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAA;CACrC,+BAiEA"}

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

@@ -0,0 +1,7 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ActionButton, PanelSection } from '@pascal-app/editor';
+import { Move, Pencil, Plus } from 'lucide-react';
+export function DormerWindowsSection({ windows, canAdd, onAdd, onEdit, onMove, }) {
+    return (_jsxs(PanelSection, { title: `Windows (${windows.length})`, children: [windows.length > 0 ? (_jsx("div", { className: "flex flex-col gap-1", children: windows.map((window, index) => (_jsxs("div", { className: "flex items-center gap-1 rounded-lg border border-border/50 bg-[#2C2C2E] p-1", children: [_jsxs("button", { className: "min-w-0 flex-1 rounded-md px-2 py-1.5 text-left transition-colors hover:bg-[#3e3e3e]", onClick: () => onEdit(window), type: "button", children: [_jsx("span", { className: "block truncate font-medium text-foreground text-xs", children: window.name || `Window ${index + 1}` }), _jsxs("span", { className: "block truncate text-[10px] text-muted-foreground capitalize", children: [window.dormerFace ?? 'front', " \u00B7 ", window.width.toFixed(2), " \u00D7", ' ', window.height.toFixed(2), " m"] })] }), _jsx("button", { "aria-label": `Edit ${window.name || `Window ${index + 1}`}`, className: "flex h-8 w-8 shrink-0 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-[#3e3e3e] hover:text-foreground", onClick: () => onEdit(window), title: "Edit window", type: "button", children: _jsx(Pencil, { className: "h-3.5 w-3.5" }) }), _jsxs("button", { "aria-label": `Move ${window.name || `Window ${index + 1}`}`, className: "flex h-8 shrink-0 items-center justify-center gap-1 rounded-md px-2 text-muted-foreground text-xs transition-colors hover:bg-[#3e3e3e] hover:text-foreground", onClick: () => onMove(window), title: "Move window", type: "button", children: [_jsx(Move, { className: "h-3.5 w-3.5" }), "Move"] })] }, window.id))) })) : (_jsx("div", { className: "px-2 py-3 text-center text-muted-foreground text-xs", children: "No windows" })), _jsxs("div", { className: "px-1 pt-2 pb-1", children: [_jsx(ActionButton, { className: "w-full", disabled: !canAdd, icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: "Add Window", onClick: onAdd }), !canAdd && (_jsx("p", { className: "px-1 pt-2 text-center text-[10px] text-muted-foreground", children: "Increase the dormer width to add another window." }))] })] }));
+}

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

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