@pascal-app/nodes 1.0.4 → 1.0.6

package/dist/roof/tool.js

@@ -1,26 +1,19 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { collectAlignmentAnchors, emitter, findLevelAboveId, getLevelElevations, getWallArcData, getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, isCurvedWall, RoofNode, RoofSegmentNode, RoofType as RoofTypeSchema, resolveBuildingForLevel, resolveLevelId, resolveRoomRoofFootprint, sceneRegistry, wallSegmentAnchors, } from '@pascal-app/core';
+import { collectAlignmentAnchors, emitter, getActiveRoofHeight, getWallArcData, getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, isCurvedWall, RoofNode, RoofSegmentNode, RoofType as RoofTypeSchema, resolveBuildingForLevel, resolveLevelId, resolveRoomRoofFootprint, sceneRegistry, wallSegmentAnchors, } from '@pascal-app/core';
 import { CursorSphere, clearSurfacePlanSnapFeedback, EDITOR_LAYER, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, resolveSurfacePlanPointSnap, snapWorldXZForActiveBuilding, triggerSFX, useEditor, useFloorplanDraftPreview, useInteractionScope, useRegistryToolContext, } from '@pascal-app/editor';
 import { generateRoofSegmentGeometry, useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
 import * as THREE from 'three';
 import { BufferGeometry, DoubleSide, Float32BufferAttribute, Vector3, } from 'three';
-import { createConicalRoofSectorAboveWall } from './conical-roof';
-import { resolveConicalRoofPlacement } from './conical-roof-placement';
-import { isStandardRoofWallEligible, parseRoofFootprintSource, resolveRoofFootprintElevation, resolveRoofFootprintWorldElevation, resolveRoofWallTopWorldElevation, subscribeToConicalRoofWallClicks, } from './roof-footprint';
-import useRoofFootprintSource from './roof-footprint-source';
-import useRoofPlacementMode, {} from './roof-placement-mode';
+import { createConicalRoofSectorAboveWall } from './conical-roof.js';
+import { resolveConicalRoofPlacement } from './conical-roof-placement.js';
+import { isStandardRoofWallEligible, parseRoofFootprintSource, resolveRoofFootprintElevation, resolveRoofFootprintWorldElevation, resolveRoofWallTopWorldElevation, subscribeToConicalRoofWallClicks, } from './roof-footprint.js';
+import useRoofFootprintSource from './roof-footprint-source.js';
+import { drawnRoofLevelTarget, drawnRoofSupport, roofLevelTarget, roofLevelTargetOffset, seatedRoofElevation, writeRoofNodes, writeSeatedRoofEdit, } from './roof-level-target.js';
+import useRoofPlacementMode, {} from './roof-placement-mode.js';
 const DEFAULT_WALL_HEIGHT = 0.5;
 const DEFAULT_PITCH_DEG = 40;
 const GRID_OFFSET = 0.02;
-function createRoofNodes(sceneApi, ops) {
-    if (sceneApi.createMany) {
-        sceneApi.createMany(ops);
-        return;
-    }
-    for (const op of ops)
-        sceneApi.upsert(op.node, op.parentId);
-}
 function placementOptions(mode) {
     return {
         allowRoofSupport: mode !== 'ground',
@@ -122,9 +115,22 @@ export const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selecte
     if (roofType === 'conical') {
         const diameter = Math.max(footprintWidth, footprintDepth);
         const curbHeight = typeof defaults.wallHeight === 'number' ? defaults.wallHeight : DEFAULT_WALL_HEIGHT;
+        const cone = RoofSegmentNode.parse({
+            pitch: DEFAULT_PITCH_DEG,
+            ...defaults,
+            roofType,
+            width: diameter,
+            depth: diameter,
+        });
+        const target = drawnRoofLevelTarget(nodes, levelId, curbHeight + getActiveRoofHeight(cone), {
+            center: [centerX, centerZ],
+            width: diameter,
+            depth: diameter,
+            roofType,
+        });
         const resolved = resolveConicalRoofPlacement({
-            nodes,
-            levelId,
+            nodes: target.nodes,
+            levelId: target.levelId,
             center: [centerX, centerZ],
             radius: diameter / 2,
             curbHeight,
@@ -150,8 +156,8 @@ export const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selecte
             support: resolved.support,
             children: [segment.id],
         });
-        createRoofNodes(sceneApi, [
-            { node: roof, parentId: levelId },
+        writeRoofNodes(sceneApi, target, [
+            { node: roof, parentId: target.levelId },
             { node: segment, parentId: roof.id },
         ]);
         triggerSFX('sfx:structure-build');
@@ -190,7 +196,14 @@ export const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selecte
             localZ = dx * Math.sin(angle) + dz * Math.cos(angle);
         }
         const placement = resolveRoofDraftPlacement(footprintWidth, footprintDepth, quarterTurn, targetRoof.rotation, roofType);
+        const sibling = targetRoof.children
+            .map((id) => nodes[id])
+            .find((node) => node?.type === 'roof-segment');
         const segment = RoofSegmentNode.parse({
+            roofSystem: sibling?.type === 'roof-segment' ? sibling.roofSystem : undefined,
+            glazing: sibling?.type === 'roof-segment' ? sibling.glazing : undefined,
+            barrelRise: sibling?.type === 'roof-segment' ? sibling.barrelRise : undefined,
+            barrelSegments: sibling?.type === 'roof-segment' ? sibling.barrelSegments : undefined,
             wallHeight: DEFAULT_WALL_HEIGHT,
             pitch: DEFAULT_PITCH_DEG,
             roofType: 'gable',
@@ -200,7 +213,9 @@ export const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selecte
             position: [localX, 0, localZ],
             rotation: placement.rotation,
         });
-        sceneApi.upsert(segment, targetRoofId);
+        writeSeatedRoofEdit(sceneApi, {
+            create: [{ node: segment, parentId: targetRoofId }],
+        });
         triggerSFX('sfx:structure-build');
         return segment.id; // Returns segment ID so it can be selected immediately
     }
@@ -220,18 +235,27 @@ export const commitRoofPlacement = (sceneApi, levelId, corner1, corner2, selecte
         position: [0, 0, 0],
         rotation: placement.rotation,
     });
+    // Drawn over a storey's walls, the roof goes on the level above them.
+    const target = drawnRoofLevelTarget(nodes, levelId, segment.wallHeight + getActiveRoofHeight(segment), { center: [centerX, centerZ], width: footprintWidth, depth: footprintDepth, roofType });
+    const support = drawnRoofSupport(target, levelId);
     // Create the roof container. Segment-shaped params (roofType, pitch, …) are
     // dropped by the RoofNode schema; surface materials in `defaults` carry over.
-    const roof = RoofNode.parse({
+    const placed = RoofNode.parse({
         ...defaults,
         name,
         position: [centerX, 0, centerZ],
-        support: { kind: 'level' },
+        support,
         children: [segment.id],
     });
+    const roof = support.kind === 'walls'
+        ? RoofNode.parse({
+            ...placed,
+            position: [centerX, seatedRoofElevation(target, placed, [segment]), centerZ],
+        })
+        : placed;
     // Create roof first (so segment can be parented to it), then segment
-    createRoofNodes(sceneApi, [
-        { node: roof, parentId: levelId },
+    writeRoofNodes(sceneApi, target, [
+        { node: roof, parentId: target.levelId },
         { node: segment, parentId: roof.id },
     ]);
     triggerSFX('sfx:structure-build');
@@ -257,26 +281,25 @@ export const commitRoofFootprint = (sceneApi, levelId, target, quarterTurn) => {
         position: [0, 0, 0],
         rotation: quarterTurn ? Math.PI / 2 : 0,
     });
-    // A roof belongs to the storey above the walls it covers, whichever level the
-    // tool was armed on; the top floor keeps it on the walls' own level.
+    // A roof belongs to the level above the walls it covers, whichever level the tool was armed
+    // on: over the top floor, the building's roof level.
     const firstWall = target.wallIds.map((id) => nodes[id]).find((node) => node?.type === 'wall');
-    const wallsLevelId = firstWall ? resolveLevelId(firstWall, nodes) : levelId;
-    const parentLevelId = (findLevelAboveId(wallsLevelId, getLevelElevations(nodes)) ??
-        wallsLevelId);
+    const wallsLevelId = (firstWall ? resolveLevelId(firstWall, nodes) : levelId);
+    const level = roofLevelTarget(nodes, wallsLevelId, getActiveRoofHeight(segment));
     const roof = RoofNode.parse({
         ...defaults,
         name: `Roof ${roofCount + 1}`,
         position: [
             target.center[0],
-            resolveRoofFootprintElevation(parentLevelId, target, nodes),
+            resolveRoofFootprintElevation(level.levelId, target, level.nodes),
             target.center[1],
         ],
         rotation: target.rotation,
         support: { kind: 'walls' },
         children: [segment.id],
     });
-    createRoofNodes(sceneApi, [
-        { node: roof, parentId: parentLevelId },
+    writeRoofNodes(sceneApi, level, [
+        { node: roof, parentId: level.levelId },
         { node: segment, parentId: roof.id },
     ]);
     triggerSFX('sfx:structure-build');
@@ -552,9 +575,15 @@ export const RoofTool = () => {
                 const diameter = Math.max(Math.abs(corner2[0] - corner1[0]), Math.abs(corner2[2] - corner1[2]));
                 const defaults = useEditor.getState().toolDefaults.roof;
                 const curbHeight = typeof defaults?.wallHeight === 'number' ? defaults.wallHeight : DEFAULT_WALL_HEIGHT;
+                const target = drawnRoofLevelTarget(sceneApi.nodes(), currentLevelId, 0, {
+                    center: [centerX, centerZ],
+                    width: diameter,
+                    depth: diameter,
+                    roofType,
+                });
                 const placement = resolveConicalRoofPlacement({
-                    nodes: sceneApi.nodes(),
-                    levelId: currentLevelId,
+                    nodes: target.nodes,
+                    levelId: target.levelId,
                     center: [centerX, centerZ],
                     radius: diameter / 2,
                     curbHeight,
@@ -562,7 +591,9 @@ export const RoofTool = () => {
                 });
                 if (placement.valid) {
                     gridY =
-                        placement.position[1] +
+                        corner1[1] +
+                            roofLevelTargetOffset(target, currentLevelId) +
+                            placement.position[1] +
                             (placement.kind === 'roof' ? placement.wallHeight - curbHeight : 0) +
                             GRID_OFFSET;
                 }
@@ -789,18 +820,28 @@ export const RoofTool = () => {
                 centerZ: footprintTarget.center[1],
             }
             : null;
+    // A roof drawn over the armed level's walls lands on the level above them; its ghost does too.
+    const drawTarget = useMemo(() => currentLevelId && footprintSource === 'draw' && previewDimensions
+        ? drawnRoofLevelTarget(nodes, currentLevelId, 0, {
+            center: [previewDimensions.centerX, previewDimensions.centerZ],
+            width: previewDimensions.length,
+            depth: previewDimensions.width,
+            roofType,
+        })
+        : null, [currentLevelId, footprintSource, nodes, previewDimensions, roofType]);
+    const drawLift = drawTarget && currentLevelId ? roofLevelTargetOffset(drawTarget, currentLevelId) : 0;
     const conicalPlacement = useMemo(() => {
-        if (!(currentLevelId && previewDimensions && roofType === 'conical'))
+        if (!(drawTarget && previewDimensions && roofType === 'conical'))
             return null;
         return resolveConicalRoofPlacement({
-            nodes,
-            levelId: currentLevelId,
+            nodes: drawTarget.nodes,
+            levelId: drawTarget.levelId,
             center: [previewDimensions.centerX, previewDimensions.centerZ],
             radius: Math.max(previewDimensions.length, previewDimensions.width) / 2,
             curbHeight: previewWallHeight,
             ...placementOptions(placementMode),
         });
-    }, [currentLevelId, nodes, placementMode, previewDimensions, previewWallHeight, roofType]);
+    }, [drawTarget, placementMode, previewDimensions, previewWallHeight, roofType]);
     const conicalWallGhost = useMemo(() => {
         if (!(roofType === 'conical' && footprintSource === 'walls' && previewedConicalWallId))
             return null;
@@ -840,9 +881,7 @@ export const RoofTool = () => {
             : previewWallHeight;
     const ghostBaseY = footprintSource !== 'draw' && footprintTarget && currentLevelId
         ? resolveRoofFootprintWorldElevation(currentLevelId, footprintTarget, nodes)
-        : conicalPlacement?.valid === true
-            ? conicalPlacement.position[1]
-            : levelY;
+        : levelY + drawLift + (conicalPlacement?.valid === true ? conicalPlacement.position[1] : 0);
     const ghostColor = footprintSource !== 'draw' &&
         footprintTarget &&
         !footprintTarget.rectangular &&

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

@@ -1,5 +1,5 @@
 import { type NodeDefinition } from '@pascal-app/core';
-import { RoofSegmentNode } from './schema';
+import { RoofSegmentNode } from './schema.js';
 /**
  * Roof segment — Stage A. Child of a roof node, owns the per-segment
  * polygon + pitch. Geometry is generated by `RoofSystem` (registered

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAoS1C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA6ExE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/roof-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAUzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAgP1C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA8FxE,CAAA"}

package/dist/roof-segment/definition.js

@@ -1,9 +1,10 @@
-import { getActiveRoofHeight, getPitchFromActiveRoofHeight, RoofSegmentNode as RoofSegmentNodeSchema, } from '@pascal-app/core';
-import { buildRoofSegmentFloorplan } from './floorplan';
-import { roofSegmentMoveTarget, roofSegmentResizeAffordance, roofSegmentRotateAffordance, } from './floorplan-affordances';
-import { matchRoofSegmentMeasurementFeature, roofSegmentMeasurementFeatures } from './measurement';
-import { roofSegmentParametrics } from './parametrics';
-import { RoofSegmentNode } from './schema';
+import { getActiveRoofHeight, getPitchFromActiveRoofHeight, getRoofSegmentResizePatch, RoofSegmentNode as RoofSegmentNodeSchema, } from '@pascal-app/core';
+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 { roofSegmentParametrics } from './parametrics.js';
+import { RoofSegmentNode } from './schema.js';
 const SIDE_HANDLE_OFFSET = 0.3;
 const HEIGHT_HANDLE_OFFSET = 0.3;
 const ROOF_HANDLE_CLEARANCE = 0.15;
@@ -55,20 +56,7 @@ function roofSegmentWidthHandle(side) {
         min: MIN_ROOF_DIM,
         gridSnap: true,
         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,
-                ...(initial.roofType === 'conical' ? { depth: newWidth } : {}),
-                position: [newCenterX, initial.position[1], newCenterZ],
-            };
-        },
+        apply: (initial, newWidth) => getRoofSegmentResizePatch(initial, 'x', sign, newWidth),
         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
@@ -96,45 +84,7 @@ function roofSegmentDepthHandle(side) {
         min: MIN_ROOF_DIM,
         gridSnap: true,
         currentValue: (n) => n.depth,
-        apply: (initial, newDepth) => {
-            // Recenter so the anchored Z edge stays at the same world point.
-            // Same math as the width handle but along the Z arm: yaw maps
-            // segment-local +Z to (sin r, cos r) in world.
-            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;
-            if (initial.roofType === 'conical') {
-                return {
-                    width: newDepth,
-                    depth: newDepth,
-                    position: [newCenterX, initial.position[1], newCenterZ],
-                };
-            }
-            // Preserve peak height — back-solve pitch for the new depth so
-            // the assembled roof height matches what it was before the drag.
-            const originalRoofHeight = getActiveRoofHeight(initial);
-            const newPitch = getPitchFromActiveRoofHeight({
-                roofType: initial.roofType,
-                width: initial.width,
-                depth: newDepth,
-                roofHeight: originalRoofHeight,
-                gambrelLowerWidthRatio: initial.gambrelLowerWidthRatio,
-                gambrelLowerHeightRatio: initial.gambrelLowerHeightRatio,
-                mansardSteepWidthRatio: initial.mansardSteepWidthRatio,
-                mansardSteepHeightRatio: initial.mansardSteepHeightRatio,
-                dutchHipWidthRatio: initial.dutchHipWidthRatio,
-                dutchHipHeightRatio: initial.dutchHipHeightRatio,
-            });
-            return {
-                depth: newDepth,
-                position: [newCenterX, initial.position[1], newCenterZ],
-                pitch: Math.max(MIN_PITCH, Math.min(MAX_PITCH, newPitch)),
-            };
-        },
+        apply: (initial, newDepth) => getRoofSegmentResizePatch(initial, 'z', sign, newDepth),
         placement: {
             position: (n) => [
                 0,
@@ -211,6 +161,8 @@ function roofSegmentPitchHandle() {
         visible: (n) => !n.managedByParent,
         apply: (initial, newPeakHeight) => {
             const roofHeight = Math.max(0, newPeakHeight - initial.wallHeight);
+            if (initial.roofType === 'barrel')
+                return { barrelRise: Math.max(0.01, Math.min(initial.depth / 2, roofHeight)) };
             const pitch = getPitchFromActiveRoofHeight({
                 roofType: initial.roofType,
                 width: initial.width,
@@ -286,7 +238,7 @@ function resolveRoofSegmentHandles(node) {
  */
 export const roofSegmentDefinition = {
     kind: 'roof-segment',
-    schemaVersion: 5,
+    schemaVersion: 7,
     schema: RoofSegmentNode,
     category: 'structure',
     surfaceRole: 'roof',
@@ -304,6 +256,23 @@ export const roofSegmentDefinition = {
         return rest;
     },
     capabilities: {
+        exterior: true,
+        revealOnEdit: [
+            'roofType',
+            'width',
+            'depth',
+            'wallHeight',
+            'pitch',
+            'overhang',
+            'wallThickness',
+            'deckThickness',
+            'barrelRise',
+            'barrelSegments',
+            'roofSystem',
+            'glazing',
+        ],
+        paint: roofSegmentPaint,
+        slots: (node) => roofSegmentSlots(node),
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,
@@ -312,14 +281,14 @@ export const roofSegmentDefinition = {
     // `shared/move-roof-tool` — routed through `MoveTool`'s registry-
     // affordance lookup rather than a hardcoded dispatcher arm.
     affordanceTools: {
-        move: () => import('../shared/move-roof-tool'),
+        move: () => import('../shared/move-roof-tool.js'),
     },
     parametrics: roofSegmentParametrics,
     handles: resolveRoofSegmentHandles,
     rendersChildren: false,
     renderer: {
         kind: 'parametric',
-        module: () => import('./renderer'),
+        module: () => import('./renderer.js'),
     },
     floorplan: buildRoofSegmentFloorplan,
     measurement: {

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,EAExB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AA4CzB;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CAsG5E,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,eAAe,CA8B5E,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,eAAe,CA2CtE,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;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"}

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

@@ -1,7 +1,8 @@
-import { snapScalar, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getRoofSegmentResizePatch, snapScalar, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { getSegmentGridStep, isAngleSnapActive, isGridSnapActive } from '@pascal-app/editor';
-import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
-import { rotateAffordanceDelta } from '../shared/rotate-affordance';
+import { commitSeatedRoofEdit } from '../roof/roof-level-target.js';
+import { createFloorplanCursorResolver } from '../shared/floorplan-cursor.js';
+import { rotateAffordanceDelta } from '../shared/rotate-affordance.js';
 const MIN_ROOF_DIM = 1;
 // Resolve world-space center + effective rotation of a roof segment by
 // composing the parent roof's position + rotation with the segment's
@@ -59,16 +60,13 @@ export const roofSegmentResizeAffordance = {
                 commit() {
                     useLiveNodeOverrides.getState().clear(segmentId);
                     const diameter = lastRadius * 2;
-                    useScene.getState().updateNode(segmentId, { width: diameter, depth: diameter });
+                    // Grown onto the walls that carry it, its roof goes to the level above them.
+                    commitSeatedRoofEdit([{ id: segmentId, data: { width: diameter, depth: diameter } }], segmentId);
                 },
             };
         }
         const { axis, side } = resize;
         const initialValue = axis === 'x' ? node.width : node.depth;
-        const initialPosition = node.position;
-        const segmentRotation = node.rotation ?? 0;
-        const armX = axis === 'x' ? Math.cos(segmentRotation) : Math.sin(segmentRotation);
-        const armZ = axis === 'x' ? -Math.sin(segmentRotation) : Math.cos(segmentRotation);
         const { effRot } = resolveSegmentFrame(node, nodes);
         const cosEff = Math.cos(effRot);
         const sinEff = Math.sin(effRot);
@@ -94,19 +92,10 @@ export const roofSegmentResizeAffordance = {
                 const step = isGridSnapActive() ? getSegmentGridStep() : 0;
                 const snappedValue = step > 0 ? snapScalar(rawValue, step) : rawValue;
                 const newValue = Math.max(MIN_ROOF_DIM, snappedValue);
-                const centerOffset = (side * (newValue - initialValue)) / 2;
-                const position = [
-                    initialPosition[0] + centerOffset * armX,
-                    initialPosition[1],
-                    initialPosition[2] + centerOffset * armZ,
-                ];
                 lastValue = newValue;
-                const dimensions = node.roofType === 'conical'
-                    ? { width: newValue, depth: newValue }
-                    : axis === 'x'
-                        ? { width: newValue }
-                        : { depth: newValue };
-                useLiveNodeOverrides.getState().set(segmentId, { ...dimensions, position });
+                useLiveNodeOverrides
+                    .getState()
+                    .set(segmentId, getRoofSegmentResizePatch(node, axis, side, newValue));
                 useScene.getState().markDirty(segmentId);
             },
             canCommit() {
@@ -114,18 +103,7 @@ export const roofSegmentResizeAffordance = {
             },
             commit() {
                 useLiveNodeOverrides.getState().clear(segmentId);
-                const centerOffset = (side * (lastValue - initialValue)) / 2;
-                const position = [
-                    initialPosition[0] + centerOffset * armX,
-                    initialPosition[1],
-                    initialPosition[2] + centerOffset * armZ,
-                ];
-                const dimensions = node.roofType === 'conical'
-                    ? { width: lastValue, depth: lastValue }
-                    : axis === 'x'
-                        ? { width: lastValue }
-                        : { depth: lastValue };
-                useScene.getState().updateNode(segmentId, { ...dimensions, position });
+                commitSeatedRoofEdit([{ id: segmentId, data: getRoofSegmentResizePatch(node, axis, side, lastValue) }], segmentId);
             },
         };
     },
@@ -163,7 +141,7 @@ export const roofSegmentRotateAffordance = {
             },
             commit() {
                 useLiveNodeOverrides.getState().clear(segmentId);
-                useScene.getState().updateNode(segmentId, { rotation: lastRotation });
+                commitSeatedRoofEdit([{ id: segmentId, data: { rotation: lastRotation } }], segmentId);
             },
         };
     },
@@ -216,7 +194,8 @@ export const roofSegmentMoveTarget = ({ node, nodes }) => {
         },
         commit() {
             useLiveNodeOverrides.getState().clear(segmentId);
-            useScene.getState().updateNode(segmentId, { position: lastLocal });
+            // Dragged onto the walls that carry it, its roof goes to the level above them.
+            commitSeatedRoofEdit([{ id: segmentId, data: { position: lastLocal } }], 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,CAyGA"}
+{"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"}

package/dist/roof-segment/floorplan.js

@@ -248,6 +248,7 @@ export function getRoofSegmentPlanLinework(node) {
         case 'conical':
         case 'flat':
             break;
+        case 'barrel':
         case 'gable':
             // Single ridge down the middle along the width axis.
             ridges.push([

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

@@ -1,2 +1,2 @@
-export { roofSegmentDefinition } from './definition';
+export { roofSegmentDefinition } from './definition.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/roof-segment/index.js

@@ -1 +1 @@
-export { roofSegmentDefinition } from './definition';
+export { roofSegmentDefinition } from './definition.js';

package/dist/roof-segment/measurement.js

@@ -1,5 +1,5 @@
 import { getRoofSegmentSurfaceY, } from '@pascal-app/core';
-import { getRoofSegmentPlanLinework } from './floorplan';
+import { getRoofSegmentPlanLinework } from './floorplan.js';
 function transformPoint(node, roof, [x, z]) {
     const segmentCos = Math.cos(node.rotation);
     const segmentSin = Math.sin(node.rotation);

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

@@ -0,0 +1,4 @@
+import { type PaintCapability } from '@pascal-app/core';
+export declare const roofSegmentPaint: PaintCapability;
+export { roofSegmentSlots } from '@pascal-app/core';
+//# sourceMappingURL=paint.d.ts.map

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

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

package/dist/roof-segment/paint.js

@@ -0,0 +1,92 @@
+import { getEffectiveRoofSurfaceMaterial, getEffectiveSegmentSurfaceMaterial, getRoofGlazing, isGlazedRoofSegment, 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';
+import { swapPreviewMaterial } from '../shared/swap-preview-material.js';
+function glazingLook(node, role) {
+    const config = getRoofGlazing(node);
+    const glass = role === 'glazing-glass';
+    return {
+        materialPreset: undefined,
+        material: {
+            preset: 'custom',
+            properties: {
+                color: glass ? config.glassColor : config.frameColor,
+                transparent: glass,
+                opacity: glass ? config.glassOpacity : 1,
+                roughness: glass ? config.glassRoughness : 0.4,
+                metalness: role === 'glazing-frame' ? 0.65 : 0,
+                side: 'front',
+            },
+        },
+    };
+}
+const glazingPaint = createSlotPaintCapability({
+    materialTarget: 'roof',
+    erasedLook: ({ node, role }) => glazingLook(node, role),
+    legacyEffective: (node, role) => glazingLook(node, role),
+    resolveRole: ({ materialIndex }) => GLAZED_ROOF_SLOTS[materialIndex ?? -1] ?? null,
+    applyPreview(args) {
+        const mesh = sceneRegistry.nodes.get(args.node.id);
+        if (!mesh?.isMesh || !Array.isArray(mesh.material))
+            return null;
+        const slot = GLAZED_ROOF_SLOTS.indexOf(args.role);
+        if (slot < 0)
+            return null;
+        const material = buildSlotPreviewMaterial(args.material, args.materialPreset);
+        if (!material)
+            return null;
+        const next = [...mesh.material];
+        next[slot] = material;
+        return swapPreviewMaterial(mesh, next);
+    },
+});
+function standardRole(index) {
+    return index === 3 ? 'top' : index === 0 ? 'edge' : index === 1 || index === 2 ? 'wall' : null;
+}
+export const roofSegmentPaint = {
+    materialTarget: 'roof',
+    resolveRole(args) {
+        return isGlazedRoofSegment(args.node)
+            ? glazingPaint.resolveRole(args)
+            : standardRole(args.materialIndex);
+    },
+    buildPatch(args) {
+        if (isGlazedRoofSegment(args.node))
+            return glazingPaint.buildPatch(args);
+        const role = args.role;
+        if (role !== 'top' && role !== 'edge' && role !== 'wall')
+            return {};
+        return buildRoofSegmentSurfaceMaterialPatch(args.node, role, args.material, args.materialPreset);
+    },
+    commit(args) {
+        if (isGlazedRoofSegment(args.node))
+            glazingPaint.commit?.(args);
+        else
+            useScene.getState().updateNode(args.node.id, roofSegmentPaint.buildPatch(args));
+    },
+    applyPreview(args) {
+        if (isGlazedRoofSegment(args.node))
+            return glazingPaint.applyPreview(args);
+        const mesh = sceneRegistry.nodes.get(args.node.id);
+        if (!mesh?.isMesh || !Array.isArray(mesh.material))
+            return null;
+        const material = buildSlotPreviewMaterial(args.material, args.materialPreset);
+        if (!material)
+            return null;
+        const next = mesh.material.map((existing, index) => standardRole(index) === args.role ? material : existing);
+        return swapPreviewMaterial(mesh, next);
+    },
+    getEffectiveMaterial(args) {
+        const node = args.node;
+        if (isGlazedRoofSegment(node))
+            return glazingPaint.getEffectiveMaterial?.(args) ?? null;
+        const role = args.role;
+        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.d.ts.map

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