@pascal-app/nodes 0.1.1

package/dist/dormer/definition.d.ts

@@ -0,0 +1,20 @@
+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.
+ *
+ * **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.
+ */
+export declare const dormerDefinition: NodeDefinition<typeof DormerNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +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,CAuE9D,CAAA"}

package/dist/dormer/definition.js

@@ -0,0 +1,491 @@
+import { DormerNode as DormerNodeSchema, } from '@pascal-app/core';
+import { buildDormerRoofCut, getDormerExposedFaces } from './csg-geometry';
+import { buildDormerFloorplan } from './floorplan';
+import { dormerPaint } from './paint';
+import { dormerParametrics } from './parametrics';
+import { DormerNode } from './schema';
+const SIDE_HANDLE_OFFSET = 0.25;
+const HEIGHT_HANDLE_OFFSET = 0.25;
+const ROTATE_CORNER_OFFSET = 0.35;
+const ROTATE_RING_OFFSET = 0.08;
+// Schema/parametrics ranges — keep these aligned with `dormerParametrics`
+// so the in-world drag and the inspector slider clamp identically.
+const MIN_DIM = 0.5;
+const MIN_HEIGHT = 0;
+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
+// would bury into the deck — this floor keeps them visible.
+const MIN_BODY_DISPLAY = 0.3;
+// Mid-Y of the dormer body in dormer-local frame. Y=0 is the eave
+// (where wall meets skirt); body extends up to `height + roofHeight`.
+// Side chevrons sit at the body midpoint so they read as "this is the
+// dormer's footprint" rather than floating at the apex or the eave.
+function getBodyMidY(n) {
+    return Math.max(n.height + n.roofHeight, MIN_BODY_DISPLAY) / 2;
+}
+// Width arrow on the +X (right) or -X (left) side. Asymmetric resize:
+// dragging one arrow grows the dormer outward from its own edge while
+// the opposite edge stays world-fixed in segment frame. The dormer's
+// registered ref frame is dormer-local (renderer applies position +
+// rotation on the registered group), so placements are in dormer-local
+// coords — no per-arrow rotation/translation compensation here.
+//
+// `apply` recomputes `position` so the anchored edge stays at the same
+// segment-local point even when the dormer is Y-rotated: project the
+// dormer's local +X onto segment frame via (cos r, -sin r), find the
+// anchored edge's segment-local XZ from the pre-drag node, then place
+// the new center half a new-width away from that anchor in the same
+// direction. Mirrors chimney + roof-segment width handle math.
+function dormerWidthHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        // 'min' = -X edge anchored (right arrow grows the +X edge outward).
+        // 'max' = +X edge anchored (left arrow grows the -X edge outward).
+        anchor: side === 'right' ? 'min' : 'max',
+        // Default 'parent' portal (no `'grandparent'` escape). Arrows
+        // portal into the host roof segment's registered mesh, which lives
+        // inside the roof renderer's `<group name="segments-wrapper">`.
+        // That wrapper is `visible={false}` by default; `RoofEditSystem`
+        // imperatively flips it to `visible={true}` whenever any accessory
+        // hosted on a segment of this roof is selected, so the portaled
+        // 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).
+        min: MIN_DIM,
+        currentValue: (n) => n.width,
+        apply: (initial, newWidth) => {
+            const rotY = initial.rotation ?? 0;
+            const armX = Math.cos(rotY);
+            const armZ = -Math.sin(rotY);
+            const anchorX = initial.position[0] - sign * (initial.width / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.width / 2) * armZ;
+            const newCenterX = anchorX + sign * (newWidth / 2) * armX;
+            const newCenterZ = anchorZ + sign * (newWidth / 2) * armZ;
+            return {
+                width: newWidth,
+                position: [newCenterX, initial.position[1], newCenterZ],
+            };
+        },
+        placement: {
+            position: (n) => [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), getBodyMidY(n), 0],
+            // Flip the left chevron so it points outward toward -X. The
+            // generic LinearArrow only auto-orients for axis 'z'; +X / -X
+            // facing is up to the descriptor.
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+    };
+}
+// Depth arrow on the +Z (front) or -Z (back) side. Asymmetric resize:
+// dragging one arrow grows the dormer outward from its own edge while
+// the opposite edge stays world-fixed in segment frame — same pattern
+// as `dormerWidthHandle`, just on the Z axis. `apply` recomputes
+// `position` so the anchored edge stays at the same segment-local point
+// even when the dormer is Y-rotated: project the dormer's local +Z onto
+// segment frame via (sin r, cos r), find the anchored edge's segment-
+// local XZ from the pre-drag node, then place the new center half a new-
+// depth away from that anchor in the same direction.
+function dormerDepthHandle(side) {
+    const sign = side === 'front' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        // 'min' = -Z edge anchored (front arrow grows the +Z edge outward).
+        // 'max' = +Z edge anchored (back arrow grows the -Z edge outward).
+        anchor: side === 'front' ? 'min' : 'max',
+        min: MIN_DIM,
+        currentValue: (n) => n.depth,
+        apply: (initial, newDepth) => {
+            const rotY = initial.rotation ?? 0;
+            const armX = Math.sin(rotY);
+            const armZ = Math.cos(rotY);
+            const anchorX = initial.position[0] - sign * (initial.depth / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.depth / 2) * armZ;
+            const newCenterX = anchorX + sign * (newDepth / 2) * armX;
+            const newCenterZ = anchorZ + sign * (newDepth / 2) * armZ;
+            return {
+                depth: newDepth,
+                position: [newCenterX, initial.position[1], newCenterZ],
+            };
+        },
+        placement: {
+            position: (n) => [0, getBodyMidY(n), sign * (n.depth / 2 + SIDE_HANDLE_OFFSET)],
+            // The renderer auto-yaws axis-'z' chevrons by -π/2 so the default
+            // points +Z (front). Flip the back chevron 180° to point -Z.
+            rotationY: () => (side === 'front' ? 0 : Math.PI),
+        },
+    };
+}
+// Wall-height tracker — dashed vertical leader from the eave (y=0) up
+// to a draggable cube at the wall top (y=height), centred on the
+// footprint. Reads as "the dormer wall is THIS tall" without claiming
+// the roof apex. Same `linear-resize axis='y'` pipeline as every other
+// height handle; `shape: 'tracker'` only swaps the visual.
+function dormerWallHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        shape: 'tracker',
+        min: MIN_HEIGHT,
+        currentValue: (n) => n.height,
+        apply: (_n, newValue) => ({ height: newValue }),
+        placement: {
+            position: (n) => [0, Math.max(n.height, 0.001), 0],
+        },
+        trackerBaseY: () => 0,
+    };
+}
+// Wall-skirt chevron — sits BELOW the eave, at the bottom of the
+// hung-wall skirt that extends down into the host roof. Drag pulls the
+// skirt's bottom edge further down (or up) to grow / shrink
+// `wallSkirtHeight`. Anchor 'max' keeps the eave (y=0) fixed; the
+// linear-resize factor (-1 for anchor 'max') flips the drag sign so
+// dragging the chevron downward increases the value 1:1.
+//
+// Plain arrow (not tracker) because tracker only renders an upward
+// leader; the dashed line would point the wrong way for a downward
+// span. The auto-orient logic in `ArrowHandle` flips the chevron to
+// point -Y when placement.y < 0, so the arrow visibly points down.
+function dormerWallSkirtHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'max',
+        min: MIN_SKIRT,
+        max: MAX_SKIRT,
+        currentValue: (n) => n.wallSkirtHeight,
+        apply: (_n, newValue) => ({ wallSkirtHeight: newValue }),
+        placement: {
+            position: (n) => [0, -(n.wallSkirtHeight + HEIGHT_HANDLE_OFFSET), 0],
+        },
+    };
+}
+// Roof-height chevron at the dormer's peak. Drag adjusts `roofHeight`
+// directly — unlike roof-segment there's no pitch back-solve because
+// dormer stores roof height as a literal scalar, not a pitch angle.
+// Placed slightly above the apex (height + roofHeight) so the chevron
+// visually attaches to the ridge.
+function dormerRoofHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_ROOF_HEIGHT,
+        max: MAX_ROOF_HEIGHT,
+        currentValue: (n) => n.roofHeight,
+        apply: (_n, newValue) => ({ roofHeight: newValue }),
+        placement: {
+            position: (n) => [0, n.height + n.roofHeight + HEIGHT_HANDLE_OFFSET, 0],
+        },
+    };
+}
+// Whole-dormer rotation gizmo at the +X / +Z corner of the footprint,
+// guide ring traces the corner-diagonal radius on hover / drag.
+// Dormer-local frame is the registered group (renderer applies
+// node.position + node.rotation there), so the default rotation pivot
+// (rideObject origin = dormer center) is correct — no
+// `rotationCenter` override needed.
+function dormerRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        // Negate the cursor delta to match three.js Y-rotation handedness
+        // (cursor atan2 ticks opposite-handed from `rotation-y`).
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: (n) => {
+                const halfX = n.width / 2 + ROTATE_CORNER_OFFSET;
+                const halfZ = n.depth / 2 + ROTATE_CORNER_OFFSET;
+                return [halfX, getBodyMidY(n), halfZ];
+            },
+            // The two-headed icon's natural bias points along +X; aim it at
+            // the corner (45° outward from the dormer's local frame).
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            radius: (n) => Math.hypot(n.width / 2, n.depth / 2) + ROTATE_RING_OFFSET,
+            y: (n) => getBodyMidY(n),
+        },
+    };
+}
+// 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'),
+    dormerDepthHandle('front'),
+    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
+    // corresponding fragment stage output" WebGPU pipeline error chimney
+    // already documented for its flue / cap-thickness / cap-overhang
+    // 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.
+    // 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.
+ *
+ * **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.
+ */
+export const dormerDefinition = {
+    kind: 'dormer',
+    schemaVersion: 1,
+    schema: DormerNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        // Zod fills in id/type via their .default() factories; we strip
+        // both so the returned shape is a partial template a consumer can
+        // spread into createNode() with a fresh id.
+        const stub = DormerNodeSchema.parse({});
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Mounts on a roof segment via `roofSegmentId`. Dirty marks
+        // cascade to the host segment's parent roof so its merged shell
+        // re-CSGs with the new cut. `buildCut` returns the segment-local
+        // geometry the merge loop subtracts from shin / deck / wall.
+        roofAccessory: {
+            buildCut: (node, _hostSegment) => buildDormerRoofCut(node),
+        },
+        // Paint dispatch for the wall / side / top surface split. The
+        // editor's selection-manager routes paint hover / click /
+        // preview through this entry rather than carrying a kind-name
+        // arm.
+        paint: dormerPaint,
+    },
+    affordanceTools: {
+        // Drag-to-place tool for duplicate + move. Reuses the placement
+        // ghost preview but seeds it from the moving (cloned) node so the
+        // duplicate keeps the source's dimensions, materials, and window
+        // options.
+        move: () => import('./move-tool'),
+    },
+    parametrics: dormerParametrics,
+    handles: dormerHandles,
+    floorplan: buildDormerFloorplan,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    tool: () => import('./tool'),
+    toolHints: [
+        { key: 'Left click', label: 'Place dormer on roof' },
+        { key: 'R / Shift+R', label: 'Rotate ghost ±15°' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Dormer',
+        description: 'House-shaped protrusion on a roof segment.',
+        icon: { kind: 'url', src: '/icons/roof.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.',
+    },
+};

package/dist/dormer/floorplan.d.ts

@@ -0,0 +1,23 @@
+import type { DormerNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+/**
+ * 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 declare function buildDormerFloorplan(node: DormerNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +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"}