@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/roof-segment/definition.render.js

@@ -0,0 +1,59 @@
+import { RoofSegmentNode as RoofSegmentNodeSchema, } from '@pascal-app/core';
+import { matchRoofSegmentMeasurementFeature, roofSegmentMeasurementFeatures } from './measurement.js';
+import { RoofSegmentNode } from './schema.js';
+import { roofSegmentSlots } from './slots.js';
+export const roofSegmentRenderDefinition = {
+    kind: 'roof-segment',
+    schemaVersion: 7,
+    schema: RoofSegmentNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = RoofSegmentNodeSchema.parse({
+            id: 'roof-segment_default',
+            type: 'roof-segment',
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        revealOnEdit: [
+            'roofType',
+            'width',
+            'depth',
+            'wallHeight',
+            'pitch',
+            'overhang',
+            'wallThickness',
+            'deckThickness',
+            'barrelRise',
+            'barrelSegments',
+            'roofSystem',
+            'glazing',
+        ],
+        slots: (node) => roofSegmentSlots(node),
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    measurement: {
+        features: (node, ctx) => roofSegmentMeasurementFeatures(node, ctx.parent?.type === 'roof' ? ctx.parent : null),
+        match: (node, ctx, point, maxDistance) => matchRoofSegmentMeasurementFeature(node, ctx.parent?.type === 'roof' ? ctx.parent : null, point, maxDistance),
+    },
+    presentation: {
+        label: 'Roof Segment',
+        description: 'A single pitched plane of a parent roof.',
+        icon: { kind: 'url', src: '/icons/roof.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 101,
+    },
+    mcp: {
+        description: 'A single roof segment with polygon footprint + pitch.',
+    },
+};

package/dist/roof-segment/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/roof-segment/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EAGxB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AA6CzB;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CAmF5E,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CA8B5E,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,eAAe,CA4CtE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/roof-segment/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EAIxB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AA0DzB;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CAyG5E,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CA8B5E,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,eAAe,CAyEtE,CAAA"}

package/dist/roof-segment/floorplan-affordances.js

@@ -1,9 +1,10 @@
-import { getRoofSegmentResizePatch, snapScalar, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { getSegmentGridStep, isAngleSnapActive, isGridSnapActive } from '@pascal-app/editor';
+import { getRoofSegmentResizePatch, MIN_ROOF_SEGMENT_DIMENSION, snapScalar, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getSegmentGridStep, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, } from '@pascal-app/editor';
 import { commitSeatedRoofEdit } from '../roof/roof-level-target.js';
+import { bearingWallThickness, catchRoofOnWalls, catchRoofSideOnWalls, placeRoofOnWalls, roofCatchWalls, segmentWallLine, } from '../roof/wall-catch.js';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor.js';
 import { rotateAffordanceDelta } from '../shared/rotate-affordance.js';
-const MIN_ROOF_DIM = 1;
+const MIN_ROOF_DIM = MIN_ROOF_SEGMENT_DIMENSION;
 // Resolve world-space center + effective rotation of a roof segment by
 // composing the parent roof's position + rotation with the segment's
 // local position. Mirrors the floorplan builder's transform so handles
@@ -68,6 +69,16 @@ export const roofSegmentResizeAffordance = {
         const { axis, side } = resize;
         const initialValue = axis === 'x' ? node.width : node.depth;
         const { effRot } = resolveSegmentFrame(node, nodes);
+        const roofId = node.parentId;
+        const roof = roofId ? nodes[roofId] : undefined;
+        const walls = roofCatchWalls(nodes, roof?.parentId);
+        const line = {
+            center: [cx, cz],
+            angle: effRot,
+            hw: node.width / 2,
+            hd: node.depth / 2,
+            wallThickness: node.wallThickness,
+        };
         const cosEff = Math.cos(effRot);
         const sinEff = Math.sin(effRot);
         // Project (planPoint - center) onto the segment's local X or Z axis
@@ -80,22 +91,34 @@ export const roofSegmentResizeAffordance = {
         };
         const initialLocal = projectLocalAxis(initialPlanPoint[0], initialPlanPoint[1]);
         let lastValue = initialValue;
+        // Sized onto the walls under it, its gable and heel walls take their thickness; off them, it
+        // keeps its own (the live override merges, so it is always written).
+        const resized = (value) => {
+            const patch = getRoofSegmentResizePatch(node, axis, side, value);
+            const thickness = bearingWallThickness(segmentWallLine(roof ?? { position: [0, 0, 0], rotation: 0 }, { ...node, ...patch }), walls);
+            return { ...patch, wallThickness: thickness ?? node.wallThickness };
+        };
         return {
             affectedIds: [segmentId],
-            apply({ planPoint }) {
+            apply({ planPoint, modifiers }) {
                 const currentLocal = projectLocalAxis(planPoint[0], planPoint[1]);
                 const delta = (currentLocal - initialLocal) * side;
                 const rawValue = initialValue + delta;
                 // Mode-aware grid step (0 outside grid mode, so `lines` / `off` resize
                 // freely — the "smooth" behaviour that used to need a held Shift). The
                 // reshaping scope opened by the dispatcher resolves the `polygon` set.
-                const step = isGridSnapActive() ? getSegmentGridStep() : 0;
-                const snappedValue = step > 0 ? snapScalar(rawValue, step) : rawValue;
+                // Alt holds the raw cursor, as in 3D.
+                const free = modifiers.altKey;
+                const step = !free && isGridSnapActive() ? getSegmentGridStep() : 0;
+                let snappedValue = step > 0 ? snapScalar(rawValue, step) : rawValue;
+                // The dragged side lands on a wall under it in grid and lines, as a move does.
+                if (!free && (isGridSnapActive() || isMagneticSnapActive())) {
+                    snappedValue =
+                        catchRoofSideOnWalls({ line, axis, side, value: rawValue, walls }) ?? snappedValue;
+                }
                 const newValue = Math.max(MIN_ROOF_DIM, snappedValue);
                 lastValue = newValue;
-                useLiveNodeOverrides
-                    .getState()
-                    .set(segmentId, getRoofSegmentResizePatch(node, axis, side, newValue));
+                useLiveNodeOverrides.getState().set(segmentId, resized(newValue));
                 useScene.getState().markDirty(segmentId);
             },
             canCommit() {
@@ -103,7 +126,7 @@ export const roofSegmentResizeAffordance = {
             },
             commit() {
                 useLiveNodeOverrides.getState().clear(segmentId);
-                commitSeatedRoofEdit([{ id: segmentId, data: getRoofSegmentResizePatch(node, axis, side, lastValue) }], segmentId);
+                commitSeatedRoofEdit([{ id: segmentId, data: resized(lastValue) }], segmentId);
             },
         };
     },
@@ -158,7 +181,7 @@ export const roofSegmentRotateAffordance = {
 export const roofSegmentMoveTarget = ({ node, nodes }) => {
     const segmentId = node.id;
     const initialY = node.position[1];
-    const { cx, cz, roofRot, cosRoof, sinRoof } = resolveSegmentFrame(node, nodes);
+    const { cx, cz, effRot, cosRoof, sinRoof } = resolveSegmentFrame(node, nodes);
     const roofId = node.parentId;
     const roof = roofId ? nodes[roofId] : undefined;
     const roofPosX = roof?.position[0] ?? 0;
@@ -167,26 +190,52 @@ export const roofSegmentMoveTarget = ({ node, nodes }) => {
         original: [cx, cz],
         metadata: node.metadata,
     });
-    // Inverse of the forward transform `[cosRoof, -sinRoof; sinRoof, cosRoof]`
-    // is `[cosRoof, sinRoof; -sinRoof, cosRoof]`. Used to project world cursor
-    // back into roof-local coords.
-    void roofRot;
+    const walls = roofCatchWalls(nodes, roof?.parentId);
     let lastLocal = [node.position[0], node.position[1], node.position[2]];
+    // Off them again, it keeps its own (the live override merges, so it is always written).
+    let lastThickness = node.wallThickness;
+    const moved = () => ({
+        position: lastLocal,
+        wallThickness: lastThickness,
+    });
     return {
         affectedIds: [segmentId],
-        apply({ planPoint }) {
+        apply({ planPoint, modifiers }) {
             // Mode-aware: `getSegmentGridStep()` is 0 outside grid mode (so `lines` /
             // `off` move freely), and the `moving` scope resolves the `polygon` set
-            // via the kind's `snapProfile` — no held-Shift bypass.
-            const step = isGridSnapActive() ? getSegmentGridStep() : 0;
+            // via the kind's `snapProfile` — no held-Shift bypass. Alt holds the raw cursor, as in 3D.
+            const free = modifiers.altKey;
+            const step = !free && isGridSnapActive() ? getSegmentGridStep() : 0;
             const snap = (value) => snapScalar(value, step);
-            const worldPoint = resolveCursor(planPoint, { snap });
+            const raw = resolveCursor(planPoint);
+            let worldPoint = resolveCursor(planPoint, { snap });
+            // Its wall line lands on the walls under it in grid and lines, its outer face on a porch's
+            // invisible walls or a deck's railings.
+            if (!free && (isGridSnapActive() || isMagneticSnapActive())) {
+                const caught = catchRoofOnWalls({
+                    lines: [
+                        {
+                            center: raw,
+                            angle: effRot,
+                            hw: node.width / 2,
+                            hd: node.depth / 2,
+                            wallThickness: node.wallThickness,
+                        },
+                    ],
+                    walls,
+                    angle: effRot,
+                });
+                worldPoint = placeRoofOnWalls(raw, worldPoint, caught, effRot);
+            }
             const dx = worldPoint[0] - roofPosX;
             const dz = worldPoint[1] - roofPosZ;
             let localX = dx * cosRoof + dz * sinRoof;
             let localZ = -dx * sinRoof + dz * cosRoof;
             lastLocal = [localX, initialY, localZ];
-            useLiveNodeOverrides.getState().set(segmentId, { position: lastLocal });
+            // Moved onto the walls under it, its gable and heel walls take their thickness.
+            lastThickness =
+                bearingWallThickness({ center: worldPoint, angle: effRot, hw: node.width / 2, hd: node.depth / 2 }, walls) ?? node.wallThickness;
+            useLiveNodeOverrides.getState().set(segmentId, moved());
             useScene.getState().markDirty(segmentId);
         },
         canCommit() {
@@ -195,7 +244,7 @@ export const roofSegmentMoveTarget = ({ node, nodes }) => {
         commit() {
             useLiveNodeOverrides.getState().clear(segmentId);
             // Dragged onto the walls that carry it, its roof goes to the level above them.
-            commitSeatedRoofEdit([{ id: segmentId, data: { position: lastLocal } }], segmentId);
+            commitSeatedRoofEdit([{ id: segmentId, data: moved() }], segmentId);
         },
     };
 };

package/dist/roof-segment/floorplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof-segment/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAiM1B;AAED,MAAM,MAAM,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC9C,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE/C,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,EAAE,CAY3E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,eAAe,GAAG;IACjE,MAAM,EAAE,OAAO,EAAE,CAAA;IACjB,IAAI,EAAE,OAAO,EAAE,CAAA;IACf,MAAM,EAAE,OAAO,EAAE,CAAA;IACjB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAC7C,CA0GA"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/roof-segment/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAKpB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAwM1B;AAED,MAAM,MAAM,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC9C,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE/C,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,EAAE,CAY3E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,eAAe,GAAG;IACjE,MAAM,EAAE,OAAO,EAAE,CAAA;IACjB,IAAI,EAAE,OAAO,EAAE,CAAA;IACf,MAAM,EAAE,OAAO,EAAE,CAAA;IACjB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAC7C,CA0GA"}

package/dist/roof-segment/floorplan.js

@@ -1,4 +1,4 @@
-import { getConicalRoofCoverage, getDutchRoofMetrics, } from '@pascal-app/core';
+import { getConicalRoofCoverage, getDutchRoofMetrics, getRoofSegmentVisibleTopBounds, } from '@pascal-app/core';
 /**
  * Stage C floor-plan builder for roof segment. Renders the segment as a
  * proper architectural roof plan: the footprint outline plus the
@@ -52,7 +52,8 @@ export function buildRoofSegmentFloorplan(node, ctx) {
     const palette = view?.palette;
     const isSelected = view?.selected ?? false;
     const isHighlighted = view?.highlighted ?? false;
-    const showSelectedChrome = isSelected || isHighlighted;
+    // Moved too: the wall line shows whether it lands on the walls' centre lines.
+    const showSelectedChrome = isSelected || isHighlighted || (view?.moving ?? false);
     // Black architectural outline by default; palette accent on select.
     // Mirrors the elevator / column style so all structural elements read
     // the same in the floor plan.
@@ -129,9 +130,8 @@ export function buildRoofSegmentFloorplan(node, ctx) {
             point: [cx, cz],
         });
         const sideArrowOffset = 0.12;
-        const rotateCornerOffset = 0.22;
+        const rotateCornerOffset = 0.3;
         const halfW = node.width / 2;
-        const halfD = node.depth / 2;
         // Effective rotation = parent roof rotation + segment-local rotation.
         // Reuse `cos` / `sin` from the corner computation above (they were
         // computed for the same `rotation` value).
@@ -151,11 +151,13 @@ export function buildRoofSegmentFloorplan(node, ctx) {
             });
         }
         else {
+            // Past the eaves and rakes the plan outlines, so the arrows sit clear of the roof's edge.
+            const eave = getRoofSegmentVisibleTopBounds(node);
             const sides = [
-                { local: [halfW + sideArrowOffset, 0], localAngle: 0, axis: 'x', side: 1 },
-                { local: [-(halfW + sideArrowOffset), 0], localAngle: Math.PI, axis: 'x', side: -1 },
-                { local: [0, halfD + sideArrowOffset], localAngle: Math.PI / 2, axis: 'z', side: 1 },
-                { local: [0, -(halfD + sideArrowOffset)], localAngle: -Math.PI / 2, axis: 'z', side: -1 },
+                { local: [eave.maxX + sideArrowOffset, 0], localAngle: 0, axis: 'x', side: 1 },
+                { local: [eave.minX - sideArrowOffset, 0], localAngle: Math.PI, axis: 'x', side: -1 },
+                { local: [0, eave.maxZ + sideArrowOffset], localAngle: Math.PI / 2, axis: 'z', side: 1 },
+                { local: [0, eave.minZ - sideArrowOffset], localAngle: -Math.PI / 2, axis: 'z', side: -1 },
             ];
             for (const side of sides) {
                 const [ox, oz] = rotateLocal(side.local[0], side.local[1]);
@@ -169,11 +171,12 @@ export function buildRoofSegmentFloorplan(node, ctx) {
                 });
             }
         }
-        // Rotate-arrow at the +X / +Z corner. Local angle π/4 puts the
-        // curved arrow's bow at the diagonal corner so it reads as a
-        // rotation gizmo around the segment centre.
+        // Rotate-arrow off the +X / +Z corner of the eaves, clear of the plan's
+        // outline, sized to a roof. Local angle π/4 puts the curved arrow's bow
+        // on the diagonal so it reads as a rotation gizmo around the centre.
         if (node.roofType !== 'conical') {
-            const [cornerX, cornerZ] = rotateLocal(halfW + rotateCornerOffset, halfD + rotateCornerOffset);
+            const eave = getRoofSegmentVisibleTopBounds(node);
+            const [cornerX, cornerZ] = rotateLocal(eave.maxX + rotateCornerOffset, eave.maxZ + rotateCornerOffset);
             const [radialX, radialZ] = rotateLocal(1, 1);
             children.push({
                 kind: 'rotate-arrow',
@@ -181,6 +184,7 @@ export function buildRoofSegmentFloorplan(node, ctx) {
                 angle: Math.atan2(radialZ, radialX),
                 affordance: 'roof-segment-rotate',
                 pivot: [cx, cz],
+                scale: 2,
             });
         }
     }

package/dist/roof-segment/paint.d.ts

@@ -1,4 +1,5 @@
-import { type PaintCapability } from '@pascal-app/core';
+import { type PaintCapability, type RoofSegmentNode, type RoofWallBand } from '@pascal-app/core';
+/** A heel or gable paints on its own: its own finish, cleared back to its fallback by the eraser. */
+export declare function wallBandPatch(band: RoofWallBand, material: RoofSegmentNode['material'], materialPreset: string | undefined): Partial<RoofSegmentNode>;
 export declare const roofSegmentPaint: PaintCapability;
-export { roofSegmentSlots } from '@pascal-app/core';
 //# sourceMappingURL=paint.d.ts.map

package/dist/roof-segment/paint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/roof-segment/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AAgDzB,eAAO,MAAM,gBAAgB,EAAE,eA8C9B,CAAA;AAED,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/roof-segment/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,YAAY,EAIlB,MAAM,kBAAkB,CAAA;AAiEzB,qGAAqG;AACrG,wBAAgB,aAAa,CAC3B,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,EACrC,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,OAAO,CAAC,eAAe,CAAC,CAG1B;AAED,eAAO,MAAM,gBAAgB,EAAE,eAoE9B,CAAA"}

package/dist/roof-segment/paint.js

@@ -1,4 +1,4 @@
-import { getEffectiveRoofSurfaceMaterial, getEffectiveSegmentSurfaceMaterial, getRoofGlazing, isGlazedRoofSegment, sceneRegistry, useScene, } from '@pascal-app/core';
+import { getEffectiveRoofSurfaceMaterial, getEffectiveSegmentSurfaceMaterial, getRoofGlazing, getRoofWallBandMaterial, isGlazedRoofSegment, roofWallBandFields, sceneRegistry, useScene, } from '@pascal-app/core';
 import { buildRoofSegmentSurfaceMaterialPatch } from '@pascal-app/editor';
 import { GLAZED_ROOF_SLOTS } from '../roof/glazed-materials.js';
 import { buildSlotPreviewMaterial, createSlotPaintCapability } from '../shared/slot-paint.js';
@@ -41,9 +41,30 @@ const glazingPaint = createSlotPaintCapability({
         return swapPreviewMaterial(mesh, next);
     },
 });
+// Slots 4–6 are the wall bands split off the wall/trim slot (the viewer's `ROOF_HEEL_MATERIAL_INDEX`…).
+const WALL_BAND_BY_INDEX = {
+    4: 'heel',
+    5: 'gable-left',
+    6: 'gable-right',
+};
+const WALL_BAND_LABELS = {
+    heel: 'Heel band',
+    'gable-left': 'Left gable',
+    'gable-right': 'Right gable',
+};
 function standardRole(index) {
+    if (index !== null && WALL_BAND_BY_INDEX[index])
+        return WALL_BAND_BY_INDEX[index];
     return index === 3 ? 'top' : index === 0 ? 'edge' : index === 1 || index === 2 ? 'wall' : null;
 }
+function isWallBand(role) {
+    return role === 'heel' || role === 'gable-left' || role === 'gable-right';
+}
+/** A heel or gable paints on its own: its own finish, cleared back to its fallback by the eraser. */
+export function wallBandPatch(band, material, materialPreset) {
+    const fields = roofWallBandFields(band);
+    return { [fields.material]: material, [fields.materialPreset]: materialPreset };
+}
 export const roofSegmentPaint = {
     materialTarget: 'roof',
     resolveRole(args) {
@@ -51,10 +72,17 @@ export const roofSegmentPaint = {
             ? glazingPaint.resolveRole(args)
             : standardRole(args.materialIndex);
     },
+    roleLabel(node, role) {
+        return isWallBand(role) && !isGlazedRoofSegment(node)
+            ? WALL_BAND_LABELS[role]
+            : null;
+    },
     buildPatch(args) {
         if (isGlazedRoofSegment(args.node))
             return glazingPaint.buildPatch(args);
         const role = args.role;
+        if (isWallBand(role))
+            return wallBandPatch(role, args.material, args.materialPreset);
         if (role !== 'top' && role !== 'edge' && role !== 'wall')
             return {};
         return buildRoofSegmentSurfaceMaterialPatch(args.node, role, args.material, args.materialPreset);
@@ -82,11 +110,23 @@ export const roofSegmentPaint = {
         if (isGlazedRoofSegment(node))
             return glazingPaint.getEffectiveMaterial?.(args) ?? null;
         const role = args.role;
+        const parent = node.parentId ? args.nodes?.[node.parentId] : undefined;
+        if (isWallBand(role)) {
+            // Unpainted, a gable shows the edge role and the heel band the roof's (else the walls').
+            const own = getRoofWallBandMaterial(node, role) ??
+                (role === 'heel' && parent?.type === 'roof'
+                    ? getRoofWallBandMaterial(parent, 'heel')
+                    : null);
+            if (own)
+                return { material: own.material, materialPreset: own.materialPreset };
+            if (role === 'heel')
+                return null;
+            const edge = getEffectiveSegmentSurfaceMaterial(node, 'edge', parent?.type === 'roof' ? getEffectiveRoofSurfaceMaterial(parent, 'edge') : undefined);
+            return { material: edge.material, materialPreset: edge.materialPreset };
+        }
         if (role !== 'top' && role !== 'edge' && role !== 'wall')
             return null;
-        const parent = node.parentId ? args.nodes?.[node.parentId] : undefined;
         const spec = getEffectiveSegmentSurfaceMaterial(node, role, parent?.type === 'roof' ? getEffectiveRoofSurfaceMaterial(parent, role) : undefined);
         return { material: spec.material, materialPreset: spec.materialPreset };
     },
 };
-export { roofSegmentSlots } from '@pascal-app/core';

package/dist/roof-segment/panel-model.d.ts

@@ -0,0 +1,23 @@
+import { type RoofBuildUp, type RoofSegmentNode } from '@pascal-app/core';
+import type { NodePanelModel } from '@pascal-app/editor';
+/** The Preset choices for the `current` value: none, the presets, and Custom while it is. */
+export declare function roofBuildUpPresetOptions(current: string | null): {
+    label: string;
+    value: string;
+}[];
+export declare function roofBuildUpPresetValue(buildUp: RoofBuildUp | undefined): string;
+/** The patch a Preset choice writes; `null` for Custom, which is no choice. */
+export declare function roofBuildUpPresetPatch(id: string): Partial<RoofSegmentNode> | null;
+export { roofBuildUpOfDeck } from '@pascal-app/core';
+/** A layer with `name`, trimmed; empty takes the name off, the kind's own name standing for it. */
+export declare function namedLayer<T extends {
+    name?: string;
+}>(layer: T, name: string): T;
+/** `next` keeps `previous`'s name while it is the same kind of material (a new thickness, say). */
+export declare function keptName<T extends {
+    kind: string;
+    name?: string;
+}>(previous: T | undefined, next: T | undefined): T | undefined;
+/** Multi-selected planes take one layers preset together, in one undo step. */
+export declare const roofSegmentPanelModel: NodePanelModel<RoofSegmentNode>;
+//# sourceMappingURL=panel-model.d.ts.map

package/dist/roof-segment/panel-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-model.d.ts","sourceRoot":"","sources":["../../src/roof-segment/panel-model.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAKxD,6FAA6F;AAC7F,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;;;IAM9D;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,CAE/E;AAED,+EAA+E;AAC/E,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI,CAIlF;AAGD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEpD,mGAAmG;AACnG,wBAAgB,UAAU,CAAC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAIjF;AAED,mGAAmG;AACnG,wBAAgB,QAAQ,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAChE,QAAQ,EAAE,CAAC,GAAG,SAAS,EACvB,IAAI,EAAE,CAAC,GAAG,SAAS,GAClB,CAAC,GAAG,SAAS,CAGf;AAED,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,eAAe,CA2BjE,CAAA"}

package/dist/roof-segment/panel-model.js

@@ -0,0 +1,64 @@
+import { isGlazedRoofSegment, ROOF_BUILD_UP_PRESETS, roofBuildUpPatch, runAsSingleSceneHistoryStep, useScene, } from '@pascal-app/core';
+const NONE = 'none';
+const CUSTOM = 'custom';
+/** The Preset choices for the `current` value: none, the presets, and Custom while it is. */
+export function roofBuildUpPresetOptions(current) {
+    return [
+        { label: 'None (deck and shingle)', value: NONE },
+        ...(current === CUSTOM ? [{ label: 'Custom', value: CUSTOM }] : []),
+        ...ROOF_BUILD_UP_PRESETS.map((preset) => ({ label: preset.label, value: preset.id })),
+    ];
+}
+export function roofBuildUpPresetValue(buildUp) {
+    return buildUp ? (buildUp.presetId ?? CUSTOM) : NONE;
+}
+/** The patch a Preset choice writes; `null` for Custom, which is no choice. */
+export function roofBuildUpPresetPatch(id) {
+    if (id === NONE)
+        return { buildUp: undefined };
+    const preset = ROOF_BUILD_UP_PRESETS.find((entry) => entry.id === id);
+    return preset ? roofBuildUpPatch(preset.buildUp) : null;
+}
+// The layers a plane without any is drawn as live in core, where Bones frames such a plane by them.
+export { roofBuildUpOfDeck } from '@pascal-app/core';
+/** A layer with `name`, trimmed; empty takes the name off, the kind's own name standing for it. */
+export function namedLayer(layer, name) {
+    const { name: _name, ...rest } = layer;
+    const trimmed = name.trim().slice(0, 60);
+    return (trimmed ? { ...rest, name: trimmed } : rest);
+}
+/** `next` keeps `previous`'s name while it is the same kind of material (a new thickness, say). */
+export function keptName(previous, next) {
+    if (!next || next.name !== undefined || previous?.name === undefined)
+        return next;
+    return next.kind === previous.kind ? { ...next, name: previous.name } : next;
+}
+/** Multi-selected planes take one layers preset together, in one undo step. */
+export const roofSegmentPanelModel = {
+    rows: () => [],
+    multiControls: ({ selection }) => {
+        const planes = selection.filter((plane) => !isGlazedRoofSegment(plane));
+        if (planes.length === 0)
+            return [];
+        const values = planes.map((plane) => roofBuildUpPresetValue(plane.buildUp));
+        const value = values.every((entry) => entry === values[0]) ? values[0] : null;
+        return [
+            {
+                id: 'roof-segment-layers-preset',
+                kind: 'select',
+                section: 'Layers',
+                label: 'Preset',
+                options: roofBuildUpPresetOptions(value),
+                value,
+                onChange: (id) => {
+                    const patch = roofBuildUpPresetPatch(id);
+                    if (!patch)
+                        return;
+                    runAsSingleSceneHistoryStep(useScene, () => useScene
+                        .getState()
+                        .updateNodes(planes.map((plane) => ({ id: plane.id, data: patch }))));
+                },
+            },
+        ];
+    },
+};

package/dist/roof-segment/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/roof-segment/panel.tsx"],"names":[],"mappings":"AA0GA,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCA6qBvC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/roof-segment/panel.tsx"],"names":[],"mappings":"AAkJA,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCAgyBvC"}