feat(wall): add endHeightOffset for sloped top edge

packages/core/src/schema/nodes/wall.ts

@@ -150,6 +150,11 @@ export const WallNode = BaseNode.extend({
   slots: z.record(z.string(), z.string()).optional(),
   thickness: z.number().optional(),
   height: z.number().optional(),
+  // Added to the wall's top only at its `end` point (`start` is unaffected),
+  // tilting the top edge along the wall's length so one side is taller than
+  // the other — e.g. a knee wall following a single-pitch roof slope.
+  /** Height offset at the end point (default 0). Must be non-negative. */
+  endHeightOffset: z.number().min(0).optional(),
   curveOffset: z.number().optional(),
   // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
   supportSlabId: z.string().optional(),
@@ -174,6 +179,7 @@ export const WallNode = BaseNode.extend({
   Wall node - used to represent a wall in the building
   - thickness: thickness in meters
   - height: height in meters
+  - endHeightOffset: added to the top only at the wall's end point, tilting the top edge so one side is taller than the other
   - fillToTerrain: extends the wall downward to the terrain without changing its authored height
   - curveOffset: midpoint sagitta offset used to bend the wall into an arc
   - start: start point of the wall in level coordinate system

packages/nodes/src/wall/panel.tsx

@@ -231,12 +231,14 @@ export default function WallPanel() {
   const followsTerrain = node.fillToTerrain === true
   const isPlaneBound = node.height == null
   const height = node.height ?? resolvedHeightMeters ?? 2.5
+  const endHeightOffset = node.endHeightOffset ?? 0
   const thickness = node.thickness ?? 0.1
   const curveOffset = getClampedWallCurveOffset(node)
   const maxCurveOffset = getMaxWallCurveOffset(node)
   const unitLabel = getLinearUnitLabel(unit)
   const displayLength = metersToLinearUnit(length, unit)
   const displayHeight = metersToLinearUnit(height, unit)
+  const displayEndHeightOffset = metersToLinearUnit(endHeightOffset, unit)
   const displayThickness = metersToLinearUnit(thickness, unit)
   const displayCurveOffset = metersToLinearUnit(curveOffset, unit)
   const displayMaxCurveOffset = metersToLinearUnit(maxCurveOffset, unit)
@@ -300,6 +302,26 @@ export default function WallPanel() {
             value={Math.round(displayHeight * 100) / 100}
           />
         )}
+        <SliderControl
+          label="End height offset"
+          max={metersToLinearUnit(3, unit)}
+          min={0}
+          onChange={(v) => {
+            handleUpdate({
+              endHeightOffset: Math.max(
+                0,
+                linearControlValueToMeters(v, unit, {
+                  maxMeters: 3,
+                  minMeters: 0,
+                }),
+              ),
+            })
+          }}
+          precision={2}
+          step={0.1}
+          unit={unitLabel}
+          value={Math.round(displayEndHeightOffset * 100) / 100}
+        />
         <div className="px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider">
           Bottom
         </div>

packages/viewer/src/systems/wall/wall-system.tsx

@@ -933,6 +933,36 @@ function mergeWallTerrainFill(
   return merged
 }
 
+/**
+ * Tilts a wall's top edge along its length so the `end` side sits taller (or
+ * shorter) than the `start` side — e.g. a knee wall following a single-pitch
+ * roof slope — instead of requiring a non-rectangular footprint. Only
+ * vertices sitting exactly at the flat extruded top (`topY`) move; a
+ * vertex's local X (0 at `start`, `wallLength` at `end`) linearly
+ * interpolates the offset from 0 to `wallNode.endHeightOffset`.
+ */
+function applyWallEndHeightSlope(
+  geometry: THREE.BufferGeometry,
+  wallNode: WallNode,
+  wallLength: number,
+  topY: number,
+): void {
+  const rawOffset = wallNode.endHeightOffset
+  console.log('[applyWallEndHeightSlope] called', { rawOffset, wallLength, topY, height: wallNode.height })
+  if (!rawOffset || wallLength < 1e-9) {
+    console.log('[applyWallEndHeightSlope] early return', { rawOffset, wallLength })
+    return
+  }
+  const endHeightOffset = Math.max(0, rawOffset)
+  const position = geometry.getAttribute('position') as THREE.BufferAttribute
+  for (let i = 0; i < position.count; i++) {
+    if (Math.abs(position.getY(i) - topY) > 1e-4) continue
+    const t = THREE.MathUtils.clamp(position.getX(i) / wallLength, 0, 1)
+    position.setY(i, topY + endHeightOffset * t)
+  }
+  position.needsUpdate = true
+}
+
 export function generateExtrudedWall(
   wallNode: WallNode,
   childrenNodes: AnyNode[],
@@ -1019,6 +1049,7 @@ export function generateExtrudedWall(
   // Rotate so extrusion direction (Z) becomes height direction (Y)
   geometry.rotateX(-Math.PI / 2)
   if (Math.abs(localBottom) > 1e-9) geometry.translate(0, localBottom, 0)
+  applyWallEndHeightSlope(geometry, wallNode, L, localBottom + height)
   geometry.computeVertexNormals()
   assignWallMaterialGroups(geometry, wallNode, boundaryEdges, effectiveWallHeight)
   ensureRenderableGeometryAttributes(geometry)