@pascal-app/editor 0.9.2 → 1.0.0-beta.2

package/src/components/tools/wall/wall-drafting.ts

@@ -2,11 +2,16 @@ import {
   type AnyNode,
   type AnyNodeId,
   DEFAULT_ANGLE_STEP,
+  DEFAULT_LEVEL_HEIGHT,
   type DoorNode,
+  GROUND_SUPPORT_ID,
   getScaledDimensions,
   type ItemNode,
+  resolveWallSupportSlabPatch,
   runAsSingleSceneHistoryStep,
   snapPointAlongAngleRay,
+  spatialGridManager,
+  terrainSupportLift,
   useScene,
   type WallNode,
   WallNode as WallSchema,
@@ -26,6 +31,7 @@ import {
   type WallDraftSnapResult,
   type WallPlanPoint,
   type WallSnapRadii,
+  wallIdsAtSnapPoint,
 } from './wall-snap-geometry'
 
 // The pure snap geometry lives in `./wall-snap-geometry`; re-exported here so
@@ -72,7 +78,11 @@ export function snapPointToGrid(point: WallPlanPoint, step = WALL_GRID_STEP): Wa
   return [snapScalarToGrid(point[0], step), snapScalarToGrid(point[1], step)]
 }
 
-function splitWallAtPoint(wall: WallNode, splitPoint: WallPlanPoint): [WallNode, WallNode] {
+function splitWallAtPoint(
+  wall: WallNode,
+  splitPoint: WallPlanPoint,
+  nodes: ReturnType<typeof useScene.getState>['nodes'],
+): [WallNode, WallNode] {
   const { id: _id, parentId: _parentId, children, ...rest } = wall
 
   const first = WallSchema.parse({
@@ -88,7 +98,24 @@ function splitWallAtPoint(wall: WallNode, splitPoint: WallPlanPoint): [WallNode,
     children: [],
   })
 
-  return [first, second]
+  if (wall.supportSlabId !== GROUND_SUPPORT_ID || !wall.parentId) {
+    return [first, second]
+  }
+
+  const levelId = wall.parentId
+  const originalElevation =
+    (terrainSupportLift(nodes, levelId, wall.start[0], wall.start[1]) ?? 0) +
+    (wall.supportOffset ?? 0)
+  const rebase = (segment: WallNode): WallNode => {
+    const terrainElevation =
+      terrainSupportLift(nodes, levelId, segment.start[0], segment.start[1]) ?? 0
+    const supportOffset = originalElevation - terrainElevation
+    return {
+      ...segment,
+      supportOffset: Math.abs(supportOffset) > 1e-6 ? supportOffset : undefined,
+    }
+  }
+  return [rebase(first), rebase(second)]
 }
 
 function pointsEqual(a: WallPlanPoint, b: WallPlanPoint, tolerance = 1e-6): boolean {
@@ -287,7 +314,7 @@ function splitWallIfNeeded(
     return { walls, point: intersection.point }
   }
 
-  const [first, second] = splitWallAtPoint(wallToSplit, intersection.point)
+  const [first, second] = splitWallAtPoint(wallToSplit, intersection.point, nodes)
   const attachmentUpdates = buildAttachmentMigrationPlan(
     wallToSplit,
     intersection.point,
@@ -393,7 +420,7 @@ export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSn
     snapRadii,
   } = args
 
-  if (bypassSnap) return { point, snap: null }
+  if (bypassSnap) return { point, snap: null, targetWallIds: [] }
 
   // Discrete special points (corner / midpoint / crossing) are taken from the
   // raw cursor so an interim grid snap can't mask them. A corner always wins,
@@ -419,8 +446,14 @@ export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSn
       ignoreWallIds,
       radius: snapRadii?.wall,
     })
-    if (wallSnap) return { point: wallSnap, snap: 'wall' }
-    return { point: basePoint, snap: null }
+    if (wallSnap) {
+      return {
+        point: wallSnap,
+        snap: 'wall',
+        targetWallIds: wallIdsAtSnapPoint(wallSnap, walls, ignoreWallIds),
+      }
+    }
+    return { point: basePoint, snap: null, targetWallIds: [] }
   }
 
   // Non-magnetic modes (grid / off / angles): connectivity still sticks so a
@@ -440,9 +473,15 @@ export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSn
     ignoreWallIds,
     radius: WALL_CONNECT_SNAP_RADIUS,
   })
-  if (connectWall) return { point: connectWall, snap: 'wall' }
+  if (connectWall) {
+    return {
+      point: connectWall,
+      snap: 'wall',
+      targetWallIds: wallIdsAtSnapPoint(connectWall, walls, ignoreWallIds),
+    }
+  }
 
-  return { point: basePoint, snap: null }
+  return { point: basePoint, snap: null, targetWallIds: [] }
 }
 
 export function snapWallDraftPoint(args: SnapWallDraftArgs): WallPlanPoint {
@@ -453,9 +492,45 @@ export function isSegmentLongEnough(start: WallPlanPoint, end: WallPlanPoint): b
   return distanceSquared(start, end) >= WALL_MIN_LENGTH * WALL_MIN_LENGTH
 }
 
+export type WallConstructionOptions = {
+  /** Pointer-decided maximum support elevation in level-local metres. */
+  supportCap?: number | null
+  /** Support source selected by the first click or inherited from a snapped wall. */
+  preferredSupportSlabId?: string | null
+  /** Frozen level-local Y shown by the draft ghost. */
+  constructionElevation?: number | null
+  /** Height shown by the draft ghost. */
+  constructionHeight?: number | null
+}
+
+export function resolveTerrainWallConstructionOptions(
+  nodes: Record<string, AnyNode>,
+  levelId: string,
+  point: WallPlanPoint,
+  defaults?: Record<string, unknown>,
+): WallConstructionOptions | undefined {
+  const constructionElevation = terrainSupportLift(nodes, levelId, point[0], point[1])
+  if (constructionElevation == null) return undefined
+
+  const level = nodes[levelId]
+  const constructionHeight =
+    typeof defaults?.height === 'number'
+      ? defaults.height
+      : level?.type === 'level'
+        ? (level.height ?? DEFAULT_LEVEL_HEIGHT)
+        : DEFAULT_LEVEL_HEIGHT
+
+  return {
+    constructionElevation,
+    constructionHeight,
+    supportCap: constructionElevation,
+  }
+}
+
 export function createWallOnCurrentLevel(
   start: WallPlanPoint,
   end: WallPlanPoint,
+  options?: WallConstructionOptions,
 ): WallNode | null {
   const currentLevelId = useViewer.getState().selection.levelId
   const { createNode, createNodes, deleteNode, nodes } = useScene.getState()
@@ -541,8 +616,52 @@ export function createWallOnCurrentLevel(
     })
 
     createNode(wall, currentLevelId)
+    const createdWall = useScene.getState().nodes[wall.id]
+    if (createdWall?.type === 'wall') {
+      const terrainBase = terrainSupportLift(
+        useScene.getState().nodes,
+        currentLevelId,
+        createdWall.start[0],
+        createdWall.start[1],
+      )
+      const preferredSupportSlabId =
+        options?.preferredSupportSlabId ??
+        (options?.constructionElevation != null && terrainBase != null ? GROUND_SUPPORT_ID : null)
+      const supportPatch = resolveWallSupportSlabPatch(createdWall, useScene.getState().nodes, {
+        maxElevation: options?.supportCap ?? null,
+        preferredSlabId: preferredSupportSlabId,
+      })
+      const supportSlabId = supportPatch.supportSlabId
+      const sourceSupport = spatialGridManager.getSlabSupportForWall(
+        currentLevelId,
+        createdWall.start,
+        createdWall.end,
+        createdWall.curveOffset,
+        createdWall.thickness,
+        supportSlabId,
+        options?.supportCap ?? null,
+      )
+      const supportOffset =
+        options?.constructionElevation == null
+          ? undefined
+          : options.constructionElevation - sourceSupport.elevation
+      const preserveDraftHeight =
+        createdWall.height == null &&
+        options?.constructionHeight != null &&
+        options.constructionElevation != null &&
+        (terrainBase != null || Math.abs(options.constructionElevation) > 1e-6)
+      useScene.getState().updateNode(createdWall.id, {
+        ...supportPatch,
+        height: preserveDraftHeight
+          ? (options?.constructionHeight ?? createdWall.height)
+          : createdWall.height,
+        supportOffset:
+          supportOffset != null && Math.abs(supportOffset) > 1e-6 ? supportOffset : undefined,
+      })
+    }
     sfxEmitter.emit('sfx:structure-build')
 
-    return wall
+    const committedWall = useScene.getState().nodes[wall.id]
+    return committedWall?.type === 'wall' ? committedWall : wall
   })
 }

package/src/components/tools/wall/wall-snap-geometry.test.ts

@@ -48,6 +48,14 @@ describe('findWallSpecialPointSnap', () => {
     expect(result?.snap).toBe('intersection')
     expect(result?.point[0]).toBeCloseTo(1, 6)
     expect(result?.point[1]).toBeCloseTo(0, 6)
+    expect(result?.targetWallIds).toEqual(['a', 'b'])
+  })
+
+  test('keeps every wall that shares a snapped endpoint as provenance', () => {
+    const walls = [makeWall([0, 0], [4, 0], 'a'), makeWall([0, 0], [0, 4], 'b')]
+    const result = findWallSpecialPointSnap([0.1, 0.1], walls)
+    expect(result?.point).toEqual([0, 0])
+    expect(result?.targetWallIds).toEqual(['a', 'b'])
   })
 
   test('corner wins over a midpoint when both are in range', () => {

package/src/components/tools/wall/wall-snap-geometry.ts

@@ -25,6 +25,12 @@ export type WallDraftSnapResult = {
    * the "magnetic" snap the beacon visualises; `null` for grid/angle-only.
    */
   snap: WallDraftSnapKind | null
+  /**
+   * Walls whose geometry produced the snap. Kept separate from `snap` so a
+   * caller can use geometry for XZ alignment while independently deciding
+   * whether the target is allowed to transfer its construction plane.
+   */
+  targetWallIds: string[]
 }
 
 export const WALL_JOIN_SNAP_RADIUS = 0.35
@@ -118,6 +124,53 @@ export function findWallSnapTarget(
   return bestTarget
 }
 
+/**
+ * Wall ids that contain an already-resolved snap point.
+ *
+ * This is provenance, not another snap pass: the tolerance only absorbs float
+ * drift around a point the snap pipeline already chose.
+ */
+export function wallIdsAtSnapPoint(
+  point: WallPlanPoint,
+  walls: WallNode[],
+  ignoreWallIds?: string[],
+  tolerance = 1e-6,
+): string[] {
+  const ignored = new Set(ignoreWallIds ?? [])
+  const toleranceSquared = tolerance * tolerance
+  const ids: string[] = []
+
+  for (const wall of walls) {
+    if (ignored.has(wall.id)) continue
+    if (
+      distanceSquared(point, wall.start) <= toleranceSquared ||
+      distanceSquared(point, wall.end) <= toleranceSquared
+    ) {
+      ids.push(wall.id)
+      continue
+    }
+
+    if (isCurvedWall(wall)) {
+      const sampleCount = Math.max(8, Math.ceil(getWallCurveLength(wall) / 0.3))
+      for (let index = 1; index < sampleCount; index += 1) {
+        const frame = getWallCurveFrameAt(wall, index / sampleCount)
+        if (distanceSquared(point, [frame.point.x, frame.point.y]) <= toleranceSquared) {
+          ids.push(wall.id)
+          break
+        }
+      }
+      continue
+    }
+
+    const projected = projectPointOntoWall(point, wall)
+    if (projected && distanceSquared(point, projected) <= toleranceSquared) {
+      ids.push(wall.id)
+    }
+  }
+
+  return ids
+}
+
 /**
  * Endpoint-only snap from the *raw* cursor (no grid pre-snap), with a
  * generous radius. Use this before `findWallSnapTarget` so the strong
@@ -320,12 +373,26 @@ export function findWallSpecialPointSnap(
   radii?: WallSnapRadii,
 ): WallDraftSnapResult | null {
   const endpoint = findWallEndpointFromRaw(point, walls, ignoreWallIds, radii?.endpoint)
-  if (endpoint) return { point: endpoint, snap: 'endpoint' }
+  if (endpoint) {
+    return {
+      point: endpoint,
+      snap: 'endpoint',
+      targetWallIds: wallIdsAtSnapPoint(endpoint, walls, ignoreWallIds),
+    }
+  }
 
   const midpoint = findWallMidpointFromRaw(point, walls, ignoreWallIds, radii?.midpoint)
   const intersection = findWallIntersectionFromRaw(point, walls, ignoreWallIds, radii?.intersection)
   return nearestCandidate(point, [
-    midpoint && { point: midpoint, snap: 'midpoint' },
-    intersection && { point: intersection, snap: 'intersection' },
+    midpoint && {
+      point: midpoint,
+      snap: 'midpoint',
+      targetWallIds: wallIdsAtSnapPoint(midpoint, walls, ignoreWallIds),
+    },
+    intersection && {
+      point: intersection,
+      snap: 'intersection',
+      targetWallIds: wallIdsAtSnapPoint(intersection, walls, ignoreWallIds),
+    },
   ])
 }

package/src/components/tools/zone/zone-tool.tsx

@@ -18,6 +18,7 @@ import {
 } from './../../../lib/surface-plan-snap'
 import { snapWorldXZForActiveBuilding } from './../../../lib/world-grid-snap'
 import useEditor, { isAngleSnapActive, isGridSnapActive } from './../../../store/use-editor'
+import { useFloorplanDraftPreview } from './../../../store/use-floorplan-draft-preview'
 import { CursorSphere } from '../shared/cursor-sphere'
 
 const Y_OFFSET = 0.02
@@ -79,6 +80,20 @@ export const ZoneTool: React.FC = () => {
     levelY: 0,
   })
 
+  useEffect(() => {
+    useFloorplanDraftPreview.getState().setPolygonDraft('zone', preview.points)
+  }, [preview.points])
+  useEffect(
+    () => () => {
+      const draftPreview = useFloorplanDraftPreview.getState()
+      if (draftPreview.polygonDraftType === 'zone') {
+        draftPreview.setPolygonDraft(null, [])
+      }
+      draftPreview.setCursorPoint(null)
+    },
+    [],
+  )
+
   useEffect(() => {
     if (!currentLevelId) return
 
@@ -192,6 +207,7 @@ export const ZoneTool: React.FC = () => {
         event.localPosition[2],
       ])
       snappedCursorPosition = displayPoint
+      useFloorplanDraftPreview.getState().setCursorPoint(displayPoint)
 
       // Play snap sound when the snapped position changes during drawing — only
       // when a quantizing mode is active (off / lines move continuously).

package/src/components/ui/action-menu/control-modes.tsx

@@ -72,7 +72,10 @@ export function ControlModes() {
   }
 
   const handleClick = (id: ControlId) => {
-    // Exit site editing first if needed
+    // Exit site editing first if needed. Sculpting is a site-phase mode, so
+    // leaving the phase is exactly the right way to leave the brush — but the
+    // order matters: `setPhase` resets the mode, and setting the mode first
+    // would have it overwritten below.
     if (isSiteEditing) {
       setPhase('structure')
       setStructureLayer('elements')

package/src/components/ui/action-menu/measurement-control.tsx

@@ -1,12 +1,17 @@
 'use client'
 
-import { useViewer } from '@pascal-app/viewer'
+import type {
+  ConstructionDimensionChainMode,
+  ConstructionDimensionMode,
+} from '@pascal-app/core'
 import {
   Box,
   Check,
   ChevronDown,
-  Eye,
-  EyeOff,
+  CircleIcon,
+  Crosshair,
+  Grid2X2,
+  Minus,
   Ruler,
   ScanSearch,
   Square,
@@ -17,6 +22,7 @@ import { useState } from 'react'
 import type { CreatableMeasurementKind } from '../../../lib/measurement-kind'
 import { cn } from '../../../lib/utils'
 import useEditor from '../../../store/use-editor'
+import useFloorplanMode from '../../../store/use-floorplan-mode'
 import { Popover, PopoverContent, PopoverTrigger } from '../primitives/popover'
 import { ActionButton } from './action-button'
 
@@ -37,27 +43,65 @@ const measurementMenuOptions = [
   ...measurementOptions,
 ] as const
 
+const constructionDimensionOptions = [
+  { mode: 'linear', chainMode: 'point-to-point', label: 'Linear dimension', icon: Ruler },
+  { mode: 'linear', chainMode: 'continuous', label: 'Continuous dimension', icon: Waypoints },
+  { mode: 'radius', chainMode: 'point-to-point', label: 'Radius dimension', icon: CircleIcon },
+  { mode: 'diameter', chainMode: 'point-to-point', label: 'Diameter dimension', icon: CircleIcon },
+  { mode: 'center-mark', chainMode: 'point-to-point', label: 'Center mark', icon: Crosshair },
+  { mode: 'chord', chainMode: 'point-to-point', label: 'Chord dimension', icon: Minus },
+  { mode: 'arc-length', chainMode: 'point-to-point', label: 'Arc length', icon: CircleIcon },
+  { mode: 'angular', chainMode: 'point-to-point', label: 'Angular dimension', icon: Triangle },
+  { mode: 'coordinate', chainMode: 'continuous', label: 'Coordinate dimensions', icon: Grid2X2 },
+] as const satisfies readonly {
+  mode: ConstructionDimensionMode
+  chainMode: ConstructionDimensionChainMode
+  label: string
+  icon: typeof Ruler
+}[]
+
 export function MeasurementControl() {
   const [isOpen, setIsOpen] = useState(false)
   const mode = useEditor((state) => state.mode)
   const tool = useEditor((state) => state.tool)
+  const floorplanMode = useFloorplanMode((state) => state.mode)
   const selectedKind = useEditor((state) => state.lastMeasurementKind)
   const activeToolKind = useEditor((state) => state.toolDefaults.measurement?.kind)
+  const constructionDimensionChainMode = useEditor(
+    (state) => state.toolDefaults['construction-dimension']?.chainMode,
+  )
+  const constructionDimensionMode = useEditor(
+    (state) => state.toolDefaults['construction-dimension']?.mode,
+  )
   const setMode = useEditor((state) => state.setMode)
   const setPhase = useEditor((state) => state.setPhase)
   const setLastMeasurementKind = useEditor((state) => state.setLastMeasurementKind)
   const setStructureLayer = useEditor((state) => state.setStructureLayer)
   const setTool = useEditor((state) => state.setTool)
   const setToolDefaults = useEditor((state) => state.setToolDefaults)
-  const showMeasurements = useViewer((state) => state.showMeasurements)
-  const setShowMeasurements = useViewer((state) => state.setShowMeasurements)
+  const setViewMode = useEditor((state) => state.setViewMode)
 
   const selectedOption =
     measurementOptions.find((option) => option.kind === selectedKind) ?? measurementOptions[0]
   const isActive = mode === 'build' && tool === 'measurement'
+  const isConstructionDimensionActive = mode === 'build' && tool === 'construction-dimension'
+  const activeConstructionDimensionOption = constructionDimensionOptions.find(
+    (option) =>
+      option.mode === (constructionDimensionMode ?? 'linear') &&
+      option.chainMode === (constructionDimensionChainMode ?? 'point-to-point'),
+  )
+  const isControlActive = isActive || isConstructionDimensionActive
   const isSmartActive = isActive && activeToolKind === 'smart'
-  const SelectedIcon = isSmartActive ? ScanSearch : selectedOption.icon
-  const selectedLabel = isSmartActive ? 'Smart' : selectedOption.label
+  const SelectedIcon = isConstructionDimensionActive
+    ? (activeConstructionDimensionOption?.icon ?? Ruler)
+    : isSmartActive
+      ? ScanSearch
+      : selectedOption.icon
+  const selectedLabel = isConstructionDimensionActive
+    ? (activeConstructionDimensionOption?.label ?? 'Linear dimension')
+    : isSmartActive
+      ? 'Smart'
+      : selectedOption.label
 
   const activateMeasurement = (kind: CreatableMeasurementKind) => {
     setPhase('structure')
@@ -69,7 +113,7 @@ export function MeasurementControl() {
   }
 
   const handlePrimaryClick = () => {
-    if (isActive) {
+    if (isControlActive) {
       setMode('select')
       return
     }
@@ -84,15 +128,31 @@ export function MeasurementControl() {
     setTool('measurement')
   }
 
+  const activateConstructionDimension = (
+    dimensionMode: ConstructionDimensionMode,
+    chainMode: ConstructionDimensionChainMode,
+  ) => {
+    if (useFloorplanMode.getState().mode !== 'expert') {
+      useFloorplanMode.getState().showExpertModeNotice('Construction Dimension')
+      return
+    }
+    setPhase('structure')
+    setStructureLayer('elements')
+    setViewMode('2d')
+    setToolDefaults('construction-dimension', { chainMode, mode: dimensionMode })
+    setMode('build')
+    setTool('construction-dimension')
+  }
+
   return (
     <Popover onOpenChange={setIsOpen} open={isOpen}>
       <div className="flex items-center">
         <ActionButton
           aria-label={`Measure: ${selectedLabel}`}
-          aria-pressed={isActive}
+          aria-pressed={isControlActive}
           className={cn(
             'rounded-r-none p-0 text-muted-foreground',
-            isActive
+            isControlActive
               ? 'bg-cyan-500/20 text-cyan-400 hover:bg-cyan-500/20'
               : 'hover:bg-cyan-500/15 hover:text-cyan-400',
           )}
@@ -128,7 +188,7 @@ export function MeasurementControl() {
 
       <PopoverContent
         align="center"
-        className="w-56 rounded-lg border-border/45 bg-background/96 p-2 shadow-elevation-3 backdrop-blur-xl"
+        className="max-h-[70vh] w-64 overflow-y-auto rounded-lg border-border/45 bg-background/96 p-2 shadow-elevation-3 backdrop-blur-xl"
         side="top"
         sideOffset={14}
       >
@@ -138,7 +198,7 @@ export function MeasurementControl() {
             const isSmart = option.kind === 'smart'
             const isSelected = isSmart
               ? isSmartActive
-              : !isSmartActive && option.kind === selectedKind
+              : !isConstructionDimensionActive && !isSmartActive && option.kind === selectedKind
             return (
               <button
                 aria-checked={isSelected}
@@ -164,23 +224,42 @@ export function MeasurementControl() {
             )
           })}
 
-          <div className="my-1.5 h-px bg-border/60" />
+          {floorplanMode === 'expert' ? (
+            <>
+              <div className="my-1.5 h-px bg-border/60" />
+              <div className="px-2.5 pt-1 pb-0.5 font-semibold text-[10px] text-muted-foreground uppercase tracking-wider">
+                Floor plan
+              </div>
 
-          <button
-            aria-checked={showMeasurements}
-            className="flex h-9 w-full items-center gap-2 rounded-md px-2.5 text-left text-muted-foreground text-sm transition-colors hover:bg-white/8 hover:text-foreground"
-            onClick={() => setShowMeasurements(!showMeasurements)}
-            role="menuitemcheckbox"
-            type="button"
-          >
-            {showMeasurements ? (
-              <Eye aria-hidden="true" className="h-4 w-4" />
-            ) : (
-              <EyeOff aria-hidden="true" className="h-4 w-4" />
-            )}
-            <span>Show measurements</span>
-            <span className="ml-auto text-xs">{showMeasurements ? 'On' : 'Off'}</span>
-          </button>
+              {constructionDimensionOptions.map((option) => {
+                const OptionIcon = option.icon
+                const isSelected =
+                  isConstructionDimensionActive && activeConstructionDimensionOption === option
+                return (
+                  <button
+                    aria-checked={isSelected}
+                    className={cn(
+                      'flex h-9 w-full items-center gap-2 rounded-md px-2.5 text-left text-sm transition-colors',
+                      isSelected
+                        ? 'bg-white/10 text-foreground'
+                        : 'text-muted-foreground hover:bg-white/8 hover:text-foreground',
+                    )}
+                    key={`${option.mode}-${option.chainMode}`}
+                    onClick={() => {
+                      activateConstructionDimension(option.mode, option.chainMode)
+                      setIsOpen(false)
+                    }}
+                    role="menuitemradio"
+                    type="button"
+                  >
+                    <OptionIcon aria-hidden="true" className="h-4 w-4" />
+                    <span>{option.label}</span>
+                    {isSelected ? <Check aria-hidden="true" className="ml-auto h-4 w-4" /> : null}
+                  </button>
+                )
+              })}
+            </>
+          ) : null}
         </div>
       </PopoverContent>
     </Popover>

package/src/components/ui/command-palette/editor-commands.tsx

@@ -1,7 +1,7 @@
 'use client'
 
 import type { AnyNodeId } from '@pascal-app/core'
-import { LevelNode, useScene } from '@pascal-app/core'
+import { DEFAULT_LEVEL_HEIGHT, LevelNode, useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import {
   AppWindow,
@@ -22,6 +22,7 @@ import {
   Minimize2,
   Moon,
   MousePointer2,
+  Mountain,
   Package,
   PaintBucket,
   PencilLine,
@@ -168,6 +169,17 @@ export function EditorCommands() {
             setMode('material-paint')
           }),
       },
+      {
+        id: 'editor.mode.terrain-sculpt',
+        label: 'Sculpt Terrain',
+        group: 'Scene',
+        icon: <Mountain className="h-4 w-4" />,
+        keywords: ['terrain', 'ground', 'elevation', 'sculpt', 'hill', 'slope', 'grade', 'dig'],
+        shortcut: ['G'],
+        // No `setPhase`: `setMode` moves to the site phase itself, and doing it
+        // here would set the phase twice with a mode reset in between.
+        execute: () => run(() => setMode('terrain-sculpt')),
+      },
 
       // ── Levels ───────────────────────────────────────────────────────────
       {
@@ -196,6 +208,7 @@ export function EditorCommands() {
             ).length
             const newLevel = LevelNode.parse({
               level: levelCount,
+              height: DEFAULT_LEVEL_HEIGHT,
               children: [],
               parentId: building.id,
             })

package/src/components/ui/controls/material-paint-panel.tsx

@@ -27,7 +27,12 @@ import { SceneMaterialList } from './scene-material-list'
  * fixed control/category header, a single scrolling catalog grid, and a fixed
  * scene-material footer (always visible, with a `+` to add a custom material).
  */
-export function MaterialPaintPanel() {
+export type MaterialPaintPanelProps = {
+  /** When provided, the catalog grid leads with a "New material" tile that invokes it. */
+  onCreateMaterialRequest?: () => void
+}
+
+export function MaterialPaintPanel({ onCreateMaterialRequest }: MaterialPaintPanelProps) {
   const activePaintMaterial = useEditor((state) => state.activePaintMaterial)
   const activePaintTarget = useEditor((state) => state.activePaintTarget)
   const setActivePaintMaterial = useEditor((state) => state.setActivePaintMaterial)
@@ -109,6 +114,7 @@ export function MaterialPaintPanel() {
       {/* Scrolls: category tabs (fixed inside) + catalog grid (the scroll). */}
       <div className="min-h-0 flex-1">
         <MaterialPicker
+          onCreateMaterialRequest={onCreateMaterialRequest}
           onSelectMaterialPreset={(materialPreset) => {
             setActivePaintMaterial({ materialPreset, sourceTarget: activePaintTarget })
           }}