@pascal-app/nodes 1.0.6 → 1.0.7

package/dist/roof-segment/definition.js

@@ -1,8 +1,12 @@
-import { getActiveRoofHeight, getPitchFromActiveRoofHeight, getRoofSegmentResizePatch, RoofSegmentNode as RoofSegmentNodeSchema, } from '@pascal-app/core';
+import { getActiveRoofHeight, getPitchFromActiveRoofHeight, getRoofSegmentResizePatch, RoofSegmentNode as RoofSegmentNodeSchema, snapScalar, } from '@pascal-app/core';
+import { getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, PANEL_MODEL_EXTENSION, } from '@pascal-app/editor';
+import { roofFloorplanAffectedIds } from '../roof/floorplan-overrides.js';
+import { bearingWallThickness, catchRoofSideOnWalls, roofCatchWalls, segmentWallLine, } from '../roof/wall-catch.js';
 import { buildRoofSegmentFloorplan } from './floorplan.js';
 import { roofSegmentMoveTarget, roofSegmentResizeAffordance, roofSegmentRotateAffordance, } from './floorplan-affordances.js';
 import { matchRoofSegmentMeasurementFeature, roofSegmentMeasurementFeatures } from './measurement.js';
 import { roofSegmentPaint, roofSegmentSlots } from './paint.js';
+import { roofSegmentPanelModel } from './panel-model.js';
 import { roofSegmentParametrics } from './parametrics.js';
 import { RoofSegmentNode } from './schema.js';
 const SIDE_HANDLE_OFFSET = 0.3;
@@ -33,6 +37,42 @@ function getSideResizeHandleY(n, localZ) {
     const roofY = n.wallHeight + roofHeight * (1 - Math.max(0, Math.min(1, t)));
     return Math.max(roofY, MIN_WALL_DISPLAY) + ROOF_HANDLE_CLEARANCE;
 }
+function roofOf(n, sceneApi) {
+    const roof = n.parentId ? sceneApi?.get(n.parentId) : undefined;
+    return roof?.type === 'roof' ? roof : undefined;
+}
+// A dragged side lands on a wall under it in grid and lines, ahead of the grid, as a move does.
+// The arrows leave `gridSnap` off so the catch sees the raw size, and grid it here when nothing
+// catches; Alt skips this hook, so the side follows the cursor.
+function snapSideOntoWalls(axis, side) {
+    return (n, value, sceneApi) => {
+        const grid = isGridSnapActive();
+        if (!grid && !isMagneticSnapActive())
+            return value;
+        const roof = roofOf(n, sceneApi);
+        if (roof) {
+            const caught = catchRoofSideOnWalls({
+                line: segmentWallLine(roof, n),
+                axis,
+                side,
+                value,
+                walls: roofCatchWalls(sceneApi.nodes(), roof.parentId),
+            });
+            if (caught !== null)
+                return caught;
+        }
+        return grid ? snapScalar(value, getSegmentGridStep()) : value;
+    };
+}
+// Sized onto the walls under it, a segment's gable and heel walls take their thickness; off them,
+// its own (written either way, so a drag back off the walls drops the thickness it previewed).
+function onBearingWalls(n, patch, sceneApi) {
+    const roof = roofOf(n, sceneApi);
+    if (!(roof && sceneApi))
+        return patch;
+    const thickness = bearingWallThickness(segmentWallLine(roof, { ...n, ...patch }), roofCatchWalls(sceneApi.nodes(), roof.parentId));
+    return { ...patch, wallThickness: thickness ?? n.wallThickness };
+}
 // Width arrow on the +X (right) or -X (left) side. Asymmetric resize:
 // dragging one arrow grows the segment outward from its own edge while
 // the opposite edge stays world-fixed — the same pattern doors use
@@ -54,9 +94,9 @@ function roofSegmentWidthHandle(side) {
         // 'max' = +X edge anchored (left arrow grows the -X edge outward).
         anchor: side === 'right' ? 'min' : 'max',
         min: MIN_ROOF_DIM,
-        gridSnap: true,
+        connectionSnap: snapSideOntoWalls('x', sign),
         currentValue: (n) => n.width,
-        apply: (initial, newWidth) => getRoofSegmentResizePatch(initial, 'x', sign, newWidth),
+        apply: (initial, newWidth, sceneApi) => onBearingWalls(initial, getRoofSegmentResizePatch(initial, 'x', sign, newWidth), sceneApi),
         placement: {
             position: (n) => [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), getSideResizeHandleY(n, 0), 0],
             // Flip the left chevron so it points outward toward -X. The
@@ -82,9 +122,9 @@ function roofSegmentDepthHandle(side) {
         axis: 'z',
         anchor: side === 'front' ? 'min' : 'max',
         min: MIN_ROOF_DIM,
-        gridSnap: true,
+        connectionSnap: snapSideOntoWalls('z', sign),
         currentValue: (n) => n.depth,
-        apply: (initial, newDepth) => getRoofSegmentResizePatch(initial, 'z', sign, newDepth),
+        apply: (initial, newDepth, sceneApi) => onBearingWalls(initial, getRoofSegmentResizePatch(initial, 'z', sign, newDepth), sceneApi),
         placement: {
             position: (n) => [
                 0,
@@ -247,6 +287,9 @@ export const roofSegmentDefinition = {
     // snapping chip and honours the active mode like every other structural
     // move. Resize / rotate run through their own reshaping scope.
     snapProfile: 'structural',
+    extensions: {
+        [PANEL_MODEL_EXTENSION]: roofSegmentPanelModel,
+    },
     defaults: () => {
         const stub = RoofSegmentNodeSchema.parse({
             id: 'roof-segment_default',
@@ -291,6 +334,8 @@ export const roofSegmentDefinition = {
         module: () => import('./renderer.js'),
     },
     floorplan: buildRoofSegmentFloorplan,
+    // Its roof draws the outline and creases from it: a live edit rebuilds that roof's plan.
+    floorplanAffectedIds: roofFloorplanAffectedIds,
     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),

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,EAGxB,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,6 +1,7 @@
 import { getRoofSegmentResizePatch, snapScalar, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { getSegmentGridStep, isAngleSnapActive, isGridSnapActive } from '@pascal-app/editor';
+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;
@@ -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,6 @@
-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;AAED,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,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,9 +110,22 @@ 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 };
     },

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":"AAiJA,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCAgxBvC"}