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

package/dist/dormer/csg-geometry.js

@@ -1,7 +1,7 @@
-import { getPitchFromActiveRoofHeight, getRoofSegmentSurfaceY, ROOF_SHAPE_DEFAULTS, } from '@pascal-app/core';
-import { ADDITION, Brush, computeGeometryBoundsTree, csgEvaluator, csgGeometry, csgMaterials, getRoofSegmentBrushes, mapRoofGroupMaterialIndex, prepareBrushForCSG, remapRoofShellFaces, roofCsgDummyMats, SUBTRACTION, } from '@pascal-app/viewer';
+import { dormerWallFacePointToDormer, getDormerWallFaceFrame, getPitchFromActiveRoofHeight, ROOF_SHAPE_DEFAULTS, } from '@pascal-app/core';
+import { ADDITION, Brush, buildOpeningCutoutGeometry, computeGeometryBoundsTree, csgEvaluator, csgGeometry, csgMaterials, getRoofSegmentBrushes, mapRoofGroupMaterialIndex, prepareBrushForCSG, remapRoofShellFaces, roofCsgDummyMats, SUBTRACTION, } from '@pascal-app/viewer';
 import * as THREE from 'three';
-import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { buildDormerShellGeometry, getDormerBodyYaw } from './geometry';
 // Legacy default for the hung-wall (skirt) height. Used as a fallback
 // when `dormer.wallSkirtHeight` is undefined (e.g. old saved scenes).
 const DORMER_DROP_BELOW = 2;
@@ -17,194 +17,20 @@ const _scale = new THREE.Vector3(1, 1, 1);
  * the live preview during slider drags so we don't re-run CSG on every
  * pointer move. Also used by the placement / move-tool ghost.
  *
- * Builds a rectangular body + simple roof in dormer-mesh-local. For
- * `flat` dormers the roof triangle is skipped. Other roof types use
- * the gable approximation — it's a rough silhouette by design.
- *
  * The wall sits at material slot 0 and the roof at slot 3 so it picks
  * up the same material array the renderer passes for the CSG output.
  */
 export function buildDormerFallbackGeometry(dormer) {
-    const w = Math.max(0.05, dormer.width);
-    const d = Math.max(0.05, dormer.depth);
-    const wallH = Math.max(0.05, dormer.height);
-    const roofH = Math.max(0, dormer.roofHeight);
-    const skirt = dormerSkirtHeight(dormer);
-    const isFlat = dormer.roofType === 'flat' || roofH === 0;
-    // Body box: foot at y = -skirt, top at y = wallH.
-    // BoxGeometry is indexed; ExtrudeGeometry below is not. mergeGeometries
-    // refuses mixed input ("index attribute exists among all geometries,
-    // or in none of them") — drop the body's index so both inputs match.
-    const indexedBody = new THREE.BoxGeometry(w, wallH + skirt, d);
-    indexedBody.translate(0, (wallH - skirt) / 2, 0);
-    const body = indexedBody.toNonIndexed();
-    indexedBody.dispose();
-    const bVtx = body.getAttribute('position').count;
-    body.clearGroups();
-    body.addGroup(0, bVtx, 0);
-    if (isFlat) {
-        if (!body.getAttribute('normal'))
-            body.computeVertexNormals();
-        return body;
-    }
-    // Roof: extruded triangle from eave (y = wallH) to peak (y = wallH + roofH).
-    // Apex points along +Y, base spans the width. Extrude along Z (depth).
-    const roofShape = new THREE.Shape();
-    roofShape.moveTo(-w / 2, 0);
-    roofShape.lineTo(w / 2, 0);
-    roofShape.lineTo(0, roofH);
-    roofShape.lineTo(-w / 2, 0);
-    const roof = new THREE.ExtrudeGeometry(roofShape, { depth: d, bevelEnabled: false });
-    roof.translate(0, wallH, -d / 2);
-    const rVtx = roof.getAttribute('position').count;
-    roof.clearGroups();
-    roof.addGroup(0, rVtx, 3);
-    const merged = mergeGeometries([body, roof], true) ?? body;
-    body.dispose();
-    roof.dispose();
-    if (!merged.getAttribute('normal'))
-        merged.computeVertexNormals();
-    return merged;
-}
-export function createDormerArchShape(w, h, archHeight) {
-    const hw = w / 2;
-    const hh = h / 2;
-    const clampedArch = Math.min(Math.max(archHeight, 0.01), Math.max(h, 0.01));
-    const springY = hh - clampedArch;
-    const segments = 32;
-    const shape = new THREE.Shape();
-    shape.moveTo(-hw, -hh);
-    shape.lineTo(hw, -hh);
-    shape.lineTo(hw, springY);
-    for (let i = 1; i <= segments; i++) {
-        const x = hw + (-hw - hw) * (i / segments);
-        const t = Math.min(Math.abs(x) / hw, 1);
-        const y = springY + clampedArch * Math.sqrt(Math.max(1 - t * t, 0));
-        shape.lineTo(x, y);
-    }
-    shape.lineTo(-hw, -hh);
-    shape.closePath();
-    return shape;
-}
-export function normalizeDormerCornerRadii(radii, w, h) {
-    const r = radii.map((v) => Math.max(v, 0));
-    const scale = Math.min(1, Math.max(w, 0) / Math.max(r[0] + r[1], 1e-6), Math.max(w, 0) / Math.max(r[3] + r[2], 1e-6), Math.max(h, 0) / Math.max(r[0] + r[3], 1e-6), Math.max(h, 0) / Math.max(r[1] + r[2], 1e-6));
-    if (scale >= 1)
-        return r;
-    return r.map((v) => v * scale);
-}
-export function createDormerRoundedShape(w, h, radii) {
-    const hw = w / 2;
-    const hh = h / 2;
-    const [tl, tr, br, bl] = normalizeDormerCornerRadii(radii, w, h);
-    const shape = new THREE.Shape();
-    shape.moveTo(-hw + bl, -hh);
-    shape.lineTo(hw - br, -hh);
-    if (br > 0)
-        shape.absarc(hw - br, -hh + br, br, -Math.PI / 2, 0, false);
-    else
-        shape.lineTo(hw, -hh);
-    shape.lineTo(hw, hh - tr);
-    if (tr > 0)
-        shape.absarc(hw - tr, hh - tr, tr, 0, Math.PI / 2, false);
-    else
-        shape.lineTo(hw, hh);
-    shape.lineTo(-hw + tl, hh);
-    if (tl > 0)
-        shape.absarc(-hw + tl, hh - tl, tl, Math.PI / 2, Math.PI, false);
-    else
-        shape.lineTo(-hw, hh);
-    shape.lineTo(-hw, -hh + bl);
-    if (bl > 0)
-        shape.absarc(-hw + bl, -hh + bl, bl, Math.PI, (3 * Math.PI) / 2, false);
-    else
-        shape.lineTo(-hw, -hh);
-    shape.closePath();
-    return shape;
+    return buildDormerShellGeometry(dormer);
 }
-function resolveDormerRadii(dormer, w, h) {
-    return normalizeDormerCornerRadii(dormer.windowCornerRadii, w, h);
-}
-function createDormerWindowCutGeometry(dormer, w, h, depth) {
-    const shape = dormer.windowShape ?? 'rectangle';
-    if (shape === 'arch') {
-        const s = createDormerArchShape(w, h, dormer.windowArchHeight ?? 0.35);
-        const geo = new THREE.ExtrudeGeometry(s, { depth, bevelEnabled: false, curveSegments: 24 });
-        geo.translate(0, 0, -depth / 2);
-        return geo;
-    }
-    if (shape === 'rounded') {
-        const radii = resolveDormerRadii(dormer, w, h);
-        const s = createDormerRoundedShape(w, h, radii);
-        const geo = new THREE.ExtrudeGeometry(s, { depth, bevelEnabled: false, curveSegments: 24 });
-        geo.translate(0, 0, -depth / 2);
-        return geo;
-    }
-    return new THREE.BoxGeometry(w, h, depth);
-}
-// Exposure datum: a face shows its window when the window CENTER clears
-// the host's structural surface line (≥ half the window visible).
-// Gating on the window BOTTOM suppressed the default window on the
-// default 40° roof (break-even ≈ 36.7° pitch) and across the whole
-// lower-slope/overhang band. A partially buried window reads as a
-// window meeting the roof line: the host shingle shell occludes the
-// buried frame from outside (the dormer roof cut only clears the inner
-// cavity, 5cm short of the gable face), and the glass panes span the
-// full opening so the wall cut never reads as a see-through hole. The
-// margin only absorbs float noise at the grazing boundary — suppress
-// only when the window is truly unplaceable.
-const WINDOW_CENTER_MIN_CLEARANCE = 0.01;
-/**
- * Which gable faces of a dormer have a visible window opening.
- * "front" = mesh-local +Z, "back" = mesh-local −Z (after the +π/2 yaw
- * bake for non-shed roofs).
- *
- * Each face centre is lifted into segment-local X *and* Z (the yaw
- * matters, and on hip hosts the end slopes fall along X) and compared
- * against the host's canonical per-type surface line via
- * `getRoofSegmentSurfaceY`, which extrapolates past the structural
- * eave instead of plateauing at the wall top — a face hanging in free
- * air past the eave keeps dropping. Gates both the CSG window-cut
- * decision (`generateDormerGeometry`) and the live render
- * (window-assembly.tsx).
- */
-export function getDormerExposedFaces(dormer, hostSegment) {
-    const halfDepth = dormer.depth / 2;
-    const dormerX = dormer.position[0] ?? 0;
-    const dormerY = dormer.position[1] ?? 0;
-    const dormerZ = dormer.position[2] ?? 0;
-    const rot = dormer.rotation ?? 0;
-    // Gable-face centres in segment-local X/Z (accounts for dormer yaw).
-    const faceDX = halfDepth * Math.sin(rot);
-    const faceDZ = halfDepth * Math.cos(rot);
-    // Window centre in segment-local Y. Mirrors `getDormerSkirtWindowDims`
-    // so both functions read the same window position: dormer-local Y=0
-    // sits at `dormer.position[1]` and the window centre sits in the
-    // skirt at -(skirtH / 2) + windowOffsetY.
-    const skirtH = dormerSkirtHeight(dormer);
-    const windowCenterSegY = dormerY - skirtH / 2 + (dormer.windowOffsetY ?? 0);
-    const clears = (faceX, faceZ) => windowCenterSegY - getRoofSegmentSurfaceY(hostSegment, faceX, faceZ) >
-        WINDOW_CENTER_MIN_CLEARANCE;
-    return {
-        front: clears(dormerX + faceDX, dormerZ + faceDZ),
-        back: clears(dormerX - faceDX, dormerZ - faceDZ),
-    };
-}
-/**
- * Computed dimensions for the window opening on a dormer's gable face.
- * The skirt (the wall extension below the eave used for CSG-trim) is
- * `DORMER_DROP_BELOW` tall, so the window sits within that band.
- */
-export function getDormerSkirtWindowDims(dormer) {
-    const skirtH = dormerSkirtHeight(dormer);
-    const maxW = Math.max(dormer.width - 0.1, 0.1);
-    const maxH = Math.max(skirtH - 0.1, 0.1);
-    const width = Math.min(Math.max(dormer.windowWidth ?? 1.2, 0.1), maxW);
-    const height = Math.min(Math.max(dormer.windowHeight ?? 1.2, 0.1), maxH);
-    const offsetX = dormer.windowOffsetX ?? 0;
-    const offsetY = dormer.windowOffsetY ?? 0;
-    const centerY = -(skirtH / 2) + offsetY;
-    return { width, height, centerY, offsetX };
+function createHostedWindowCutGeometry(window) {
+    const depth = 0.4;
+    return buildOpeningCutoutGeometry(window, {
+        left: -window.width / 2,
+        right: window.width / 2,
+        bottom: -window.height / 2,
+        top: window.height / 2,
+    }, depth, 0.05);
 }
 /**
  * Build the trimmed dormer geometry hosted on a roof segment. The
@@ -213,9 +39,9 @@ export function getDormerSkirtWindowDims(dormer) {
  * CSG-subtracted in dormer-mesh-local space. Window openings are then
  * subtracted on each exposed gable face.
  */
-export function generateDormerGeometry(dormer, hostSegment) {
+export function generateDormerGeometry(dormer, hostSegment, hostedWindows = []) {
     const isShed = dormer.roofType === 'shed';
-    const yawBake = isShed ? 0 : Math.PI / 2;
+    const yawBake = getDormerBodyYaw(dormer);
     const segWidth = isShed ? dormer.width : dormer.depth;
     const segDepth = isShed ? dormer.depth : dormer.width;
     const skirt = dormerSkirtHeight(dormer);
@@ -228,7 +54,7 @@ export function generateDormerGeometry(dormer, hostSegment) {
         type: 'roof-segment',
         parentId: null,
         visible: true,
-        metadata: null,
+        metadata: {},
         children: [],
         position: [0, 0, 0],
         rotation: 0,
@@ -270,6 +96,9 @@ export function generateDormerGeometry(dormer, hostSegment) {
         deckThickness: 0.04,
         overhang: 0.08,
         shingleThickness: 0.02,
+        managedByParent: false,
+        wallShell: 'auto',
+        shedInsetEndPanels: false,
     };
     const dormerBrushes = getRoofSegmentBrushes(virtualSegment);
     if (!dormerBrushes) {
@@ -332,14 +161,14 @@ export function generateDormerGeometry(dormer, hostSegment) {
             hostSolid = null;
             dormerSolid = trimmed;
         }
-        // Cut window openings on exposed gable faces.
-        const exposed = getDormerExposedFaces(dormer, hostSegment);
-        const skirtWin = getDormerSkirtWindowDims(dormer);
-        const gableHalfZ = dormer.depth / 2;
-        const cutDepth = 0.4;
-        const cutFace = (zSign) => {
-            const cutGeo = createDormerWindowCutGeometry(dormer, skirtWin.width, skirtWin.height, cutDepth);
-            cutGeo.translate(skirtWin.offsetX, skirtWin.centerY, zSign * gableHalfZ);
+        // Cut hosted window openings in dormer-local face coordinates.
+        const cutWindow = (window) => {
+            const face = window.dormerFace ?? 'front';
+            const frame = getDormerWallFaceFrame(dormer, face);
+            const center = dormerWallFacePointToDormer(dormer, face, window.position);
+            const cutGeo = createHostedWindowCutGeometry(window);
+            cutGeo.rotateY(frame.yaw);
+            cutGeo.translate(center[0], center[1], center[2]);
             if (!cutGeo.getIndex()) {
                 const posCount = cutGeo.getAttribute('position').count;
                 const idx = new Uint32Array(posCount);
@@ -359,10 +188,8 @@ export function generateDormerGeometry(dormer, hostSegment) {
             brush.geometry.dispose();
             dormerSolid = result;
         };
-        if (exposed.front)
-            cutFace(+1);
-        if (exposed.back)
-            cutFace(-1);
+        for (const window of hostedWindows)
+            cutWindow(window);
         resultGeo = csgGeometry(dormerSolid);
         const resultMaterials = csgMaterials(dormerSolid);
         const matToIndex = new Map([
@@ -414,10 +241,10 @@ export function generateDormerGeometry(dormer, hostSegment) {
  * Shapes per roof type:
  * - **flat**:                a plain box (top flush with the eave; the
  *                            dormer body has no roof above wallH).
- * - **shed**:                trapezoid in YZ, extruded along X. Eave
- *                            at z=+d/2 (y=wallH), peak at z=-d/2
- *                            (y=wallH+roofH) — matches the slope
- *                            direction the dormer body uses.
+ * - **shed**:                trapezoid in YZ, extruded along X. The
+ *                            base shape is high at z=-d/2; the caller
+ *                            flips it when the configured high side is
+ *                            the front.
  * - **gable / gambrel**:     pentagon (rectangle + symmetric triangle)
  *                            in XY, extruded along Z. Ridge runs
  *                            along Z (mesh-Z = virtualSegment-X after
@@ -675,10 +502,12 @@ export function buildDormerRoofCut(dormer) {
     //   - hip / dutch / mansard:  pyramid (narrows on all 4 sides)
     //   - gable / gambrel:        pentagon (narrows along width axis)
     const geo = buildDormerCutShape(dormer.roofType, innerW, innerD, skirt, wallH, roofH);
-    // Yaw in the geometry's own (un-translated) frame so the cut aligns
-    // with the dormer's footprint after rotation.
-    if (Math.abs(dormer.rotation) > 1e-4) {
-        geo.rotateY(dormer.rotation);
+    // Yaw in the geometry's own (un-translated) frame so the cut follows
+    // both the shed pitch direction and the dormer's footprint rotation.
+    const shedDirectionYaw = dormer.roofType === 'shed' && dormer.shedHighSide === 'front' ? Math.PI : 0;
+    const cutYaw = shedDirectionYaw + dormer.rotation;
+    if (Math.abs(cutYaw) > 1e-4) {
+        geo.rotateY(cutYaw);
     }
     // Translate into segment-local. position[1] becomes the dormer's
     // local Y = 0 (the wall foot / eave line); the shape's foot at

package/dist/dormer/definition.d.ts

@@ -2,19 +2,11 @@ import { type NodeDefinition } from '@pascal-app/core';
 import { DormerNode } from './schema';
 /**
  * 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 declare const dormerDefinition: NodeDefinition<typeof DormerNode>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/dormer/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAmarC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAwE9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/dormer/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAqPrC;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA8E9D,CAAA"}

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"}