@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/dormer/definition.edit.js

@@ -0,0 +1,214 @@
+import { buildDormerFloorplan } from './floorplan.js';
+import { dormerPaint } from './paint.js';
+import { dormerParametrics } from './parametrics.js';
+const SIDE_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;
+// 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.
+        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,
+    };
+}
+// 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),
+        },
+    };
+}
+const dormerHandles = [
+    dormerWidthHandle('right'),
+    dormerWidthHandle('left'),
+    dormerDepthHandle('front'),
+    dormerDepthHandle('back'),
+    dormerWallHeightHandle(),
+    dormerRotateHandle(),
+    // 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, keep
+    // the current compact set.
+    // dormerWallSkirtHandle(),
+    // dormerRoofHeightHandle(),
+];
+export const dormerEditContribution = {
+    capabilities: {
+        // 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.js'),
+    },
+    parametrics: dormerParametrics,
+    handles: dormerHandles,
+    floorplan: buildDormerFloorplan,
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Left click', label: 'Place dormer on roof' },
+        { key: 'R / Shift+R', label: 'Rotate ghost ±15°' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};

package/dist/dormer/definition.js

@@ -1,319 +1,4 @@
-import { DormerNode as DormerNodeSchema, } from '@pascal-app/core';
-import { buildDormerRoofCut } from './csg-geometry.js';
-import { buildDormerFloorplan } from './floorplan.js';
-import { dormerPaint } from './paint.js';
-import { dormerParametrics } from './parametrics.js';
-import { DormerNode } from './schema.js';
-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;
-// 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.
-        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),
-        },
-    };
-}
-const dormerHandles = [
-    dormerWidthHandle('right'),
-    dormerWidthHandle('left'),
-    dormerDepthHandle('front'),
-    dormerDepthHandle('back'),
-    dormerWallHeightHandle(),
-    dormerRotateHandle(),
-    // 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, keep
-    // the current compact set.
-    // dormerWallSkirtHandle(),
-    // dormerRoofHeightHandle(),
-];
-/**
- * Dormer — a small house-shaped protrusion sitting on top of a roof
- * segment. Windows are hosted child nodes; the legacy window* fields remain
- * in the schema only so scene migration can preserve older dormers.
- *
- * 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: 4,
-    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: {
-        exterior: true,
-        selectable: { hitVolume: 'bbox' },
-        // 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
-        // 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,
-    },
-    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
-        // duplicate keeps the source's dimensions, materials, and window
-        // options.
-        move: () => import('./move-tool.js'),
-    },
-    parametrics: dormerParametrics,
-    handles: dormerHandles,
-    floorplan: buildDormerFloorplan,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./preview.js'),
-    tool: () => import('./tool.js'),
-    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/dormer.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 125,
-    },
-    mcp: {
-        description: 'A dormer on a roof segment. Its windows are hosted WindowNode children.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { dormerEditContribution } from './definition.edit.js';
+import { dormerRenderDefinition } from './definition.render.js';
+export const dormerDefinition = composeNodeDefinition(dormerRenderDefinition, dormerEditContribution);

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

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { DormerNode } from './schema.js';
+export declare const dormerRenderDefinition: NodeRenderDefinition<typeof DormerNode> & {
+    kind: 'dormer';
+};
+//# sourceMappingURL=definition.render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/dormer/definition.render.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAErC,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,OAAO,UAAU,CAAC,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAkD5F,CAAA"}

package/dist/dormer/definition.render.js

@@ -0,0 +1,52 @@
+import { DormerNode as DormerNodeSchema, } from '@pascal-app/core';
+import { buildDormerRoofCut } from './csg-geometry.js';
+import { DormerNode } from './schema.js';
+export const dormerRenderDefinition = {
+    kind: 'dormer',
+    schemaVersion: 4,
+    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: {
+        exterior: true,
+        selectable: { hitVolume: 'bbox' },
+        // 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
+        // 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),
+        },
+    },
+    relations: {
+        hosts: ['window'],
+        cascadeDelete: 'descendants',
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Dormer',
+        description: 'House-shaped protrusion on a roof segment.',
+        icon: { kind: 'url', src: '/icons/dormer.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 125,
+    },
+    mcp: {
+        description: 'A dormer on a roof segment. Its windows are hosted WindowNode children.',
+    },
+};

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

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

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

@@ -1,5 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { usePascalI18n } from '@pascal-app/core';
 import { ActionButton, ActionGroup, PanelSection } from '@pascal-app/editor';
 import { Copy, Move, Trash2 } from 'lucide-react';
 /**
@@ -7,5 +8,6 @@ import { Copy, Move, Trash2 } from 'lucide-react';
  * inspector. Pure presentation — owners pass the three handlers.
  */
 export function DormerActionsSection({ onMove, onDuplicate, onDelete, }) {
-    return (_jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: onMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: onDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-600 dark:text-red-400" }), label: "Delete", onClick: onDelete })] }) }));
+    const i18n = usePascalI18n();
+    return (_jsx(PanelSection, { title: i18n._({ id: 'node.dormer.panelActionsSection.actions', message: 'Actions' }), children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: i18n._({ id: 'node.dormer.panelActionsSection.move', message: 'Move' }), onClick: onMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: i18n._({ id: 'node.dormer.panelActionsSection.duplicate', message: 'Duplicate' }), onClick: onDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-600 dark:text-red-400" }), label: i18n._({ id: 'node.dormer.panelActionsSection.delete', message: 'Delete' }), onClick: onDelete })] }) }));
 }

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

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

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

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { sceneRegistry, useScene, } from '@pascal-app/core';
+import { sceneRegistry, usePascalI18n, useScene, } from '@pascal-app/core';
 import { PanelSection, SliderControl } from '@pascal-app/editor';
 import { useMemo } from 'react';
 import { Vector3 } from 'three';
@@ -12,6 +12,7 @@ import { Vector3 } from 'three';
  * local commits, including the cross-segment reparent case.
  */
 export function DormerPositionSection({ node, segment, roof, selectedId, previewProp, commitProp, }) {
+    const i18n = usePascalI18n();
     const px = node.position[0];
     const py = node.position[1];
     const pz = node.position[2];
@@ -136,7 +137,7 @@ export function DormerPositionSection({ node, segment, roof, selectedId, preview
         }
         commitProp({ rotation: newWorldRot - ancestorWorldY });
     };
-    return (_jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(worldMaxX * 10) / 10, min: Math.round(worldMinX * 10) / 10, onChange: (newWorldX) => {
+    return (_jsxs(PanelSection, { title: i18n._({ id: 'node.dormer.panelPositionSection.position', message: 'Position' }), children: [_jsx(SliderControl, { label: "X", max: Math.round(worldMaxX * 10) / 10, min: Math.round(worldMinX * 10) / 10, onChange: (newWorldX) => {
                     if (!segment)
                         return;
                     const local = worldToSegLocal(newWorldX, worldZ_now, segment);
@@ -146,7 +147,7 @@ export function DormerPositionSection({ node, segment, roof, selectedId, preview
                         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: worldZ_now }), _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: i18n._({ id: 'node.dormer.panelPositionSection.rotation', message: 'Rotation' }), max: 180, min: -180, onChange: (degrees) => {
                     const newWorldRot = (degrees * Math.PI) / 180;
                     let ancestorWorldY = 0;
                     if (segment) {