@pascal-app/editor 1.0.0-beta.5 → 1.0.0

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

@@ -1,15 +1,20 @@
-import { beforeEach, describe, expect, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import {
   type AnyNode,
   type AnyNodeId,
   applyHeightPatch,
+  BlockNode,
   CeilingNode,
   createTerrainField,
   DoorNode as DoorSchema,
   encodeTerrainField,
   flattenPatch,
   GROUND_SUPPORT_ID,
+  getFloorPlacedElevation,
   initSpaceDetectionSync,
+  nodeRegistry,
+  registerNode,
+  resolveTerrainWallConstructionOptions,
   runAsSingleSceneHistoryStep,
   SlabNode,
   spatialGridManager,
@@ -23,7 +28,6 @@ import useInteractionScope from '../../../store/use-interaction-scope'
 import {
   createWallOnCurrentLevel,
   resolveEndpointWallSplit,
-  resolveTerrainWallConstructionOptions,
   snapWallDraftPointDetailed,
 } from './wall-drafting'
 import type { WallPlanPoint } from './wall-snap-geometry'
@@ -139,6 +143,15 @@ function levelWalls(): WallNode[] {
 }
 
 describe('createWallOnCurrentLevel', () => {
+  // Set by tests that mutate the process-wide node registry; restored here
+  // so the mutation can't leak into later test files (order-dependent flakes).
+  let restoreRegistry: (() => void) | undefined
+
+  afterEach(() => {
+    restoreRegistry?.()
+    restoreRegistry = undefined
+  })
+
   beforeEach(() => {
     useViewer.setState({
       selection: {
@@ -198,6 +211,181 @@ describe('createWallOnCurrentLevel', () => {
     expect(support.elevation).toBe(1.75)
   })
 
+  test('never exposes a raised wall at floor elevation during commit', () => {
+    const observed: WallNode[] = []
+    const unsubscribe = useScene.subscribe((state) => {
+      const wall = Object.values(state.nodes).find(
+        (node): node is WallNode => node?.type === 'wall' && node.id !== 'wall_a',
+      )
+      if (wall) observed.push(wall)
+    })
+
+    const created = createWallOnCurrentLevel([2, 2], [3, 2], {
+      supportCap: 1.75,
+      preferredSupportSlabId: GROUND_SUPPORT_ID,
+      constructionElevation: 1.75,
+      constructionHeight: 2.5,
+      flatConstructionBase: true,
+    })
+    unsubscribe()
+
+    expect(created).not.toBeNull()
+    expect(observed.length).toBeGreaterThan(0)
+    expect(observed.every((wall) => wall.supportSlabId === GROUND_SUPPORT_ID)).toBe(true)
+    expect(observed.every((wall) => wall.supportOffset === 1.75)).toBe(true)
+  })
+
+  test('keeps a node-top room plane flat across changing terrain', () => {
+    const field = createTerrainField({ cols: 5, rows: 5, spacing: 1, origin: [0, 0] })
+    const patch = flattenPatch(field, { minX: 3.5, minZ: 0, maxX: 4, maxZ: 4 }, 1)
+    if (!patch) throw new Error('Expected terrain patch')
+    const terrain = applyHeightPatch(field, patch)
+    const site = {
+      id: 'site_test',
+      type: 'site',
+      object: 'node',
+      parentId: null,
+      visible: true,
+      metadata: {},
+      children: ['building_test'],
+      terrain: encodeTerrainField(terrain),
+    } as unknown as AnyNode
+    const building = {
+      id: 'building_test',
+      type: 'building',
+      object: 'node',
+      parentId: site.id,
+      visible: true,
+      metadata: {},
+      children: [LEVEL_ID],
+      position: [0, 0, 0],
+      rotation: [0, 0, 0],
+    } as AnyNode
+    const level = {
+      id: LEVEL_ID,
+      type: 'level',
+      object: 'node',
+      parentId: building.id,
+      visible: true,
+      metadata: {},
+      children: [],
+      level: 0,
+      baseElevation: 0,
+      height: 3,
+    } as AnyNode
+    useScene.setState({
+      nodes: Object.fromEntries([site, building, level].map((node) => [node.id, node])),
+      rootNodeIds: [site.id],
+      dirtyNodes: new Set(),
+    } as never)
+
+    const lowTerrainWall = createWallOnCurrentLevel([0, 0], [1, 0], {
+      constructionElevation: 3,
+      constructionHeight: 2.5,
+      flatConstructionBase: true,
+      supportCap: 3,
+    })
+    const highTerrainWall = createWallOnCurrentLevel([4, 0], [4, 1], {
+      constructionElevation: 3,
+      constructionHeight: 2.5,
+      flatConstructionBase: true,
+      supportCap: 3,
+    })
+
+    expect(lowTerrainWall?.supportSlabId).toBe(GROUND_SUPPORT_ID)
+    expect(highTerrainWall?.supportSlabId).toBe(GROUND_SUPPORT_ID)
+    expect(lowTerrainWall?.supportOffset).toBeCloseTo(3)
+    expect(highTerrainWall?.supportOffset).toBeCloseTo(2)
+    expect(
+      spatialGridManager.getSlabSupportForWall(
+        LEVEL_ID,
+        lowTerrainWall!.start,
+        lowTerrainWall!.end,
+        lowTerrainWall!.curveOffset,
+        lowTerrainWall!.thickness,
+        lowTerrainWall!.supportSlabId,
+        undefined,
+        lowTerrainWall!.supportOffset,
+      ).elevation,
+    ).toBeCloseTo(3)
+    expect(
+      spatialGridManager.getSlabSupportForWall(
+        LEVEL_ID,
+        highTerrainWall!.start,
+        highTerrainWall!.end,
+        highTerrainWall!.curveOffset,
+        highTerrainWall!.thickness,
+        highTerrainWall!.supportSlabId,
+        undefined,
+        highTerrainWall!.supportOffset,
+      ).elevation,
+    ).toBeCloseTo(3)
+  })
+
+  test('pins an existing construction source before a generated room slab can lift it', () => {
+    // The reset + throwaway `block` registration is scoped to this test —
+    // the registry is a process-wide singleton, so leaking it would leave
+    // later test FILES with a stripped registry (order-dependent flakes).
+    restoreRegistry = nodeRegistry._snapshot()
+    nodeRegistry._reset()
+    spatialGridManager.clear()
+    registerNode({
+      kind: 'block',
+      schemaVersion: 2,
+      schema: BlockNode,
+      category: 'structure',
+      defaults: () => BlockNode.parse({ name: 'Block' }),
+      capabilities: {
+        floorPlaced: {
+          footprint: () => ({ dimensions: [4, 2.4, 4], rotation: [0, 0, 0] }),
+        },
+      },
+    } as never)
+
+    const slope = BlockNode.parse({
+      name: 'Existing slope',
+      parentId: LEVEL_ID,
+      position: [0, 0, 0],
+    })
+    seedLevel([makeWall([0, 0], [4, 0], 'wall_a')], [slope as AnyNode])
+
+    createWallOnCurrentLevel([0, 1], [1, 1], {
+      constructionElevation: 2.4,
+      constructionHeight: 2.5,
+      constructionSourceNodeId: slope.id,
+      flatConstructionBase: true,
+      supportCap: 2.4,
+    })
+
+    const pinnedSlope = useScene.getState().nodes[slope.id] as BlockNode
+    expect(pinnedSlope.supportSlabId).toBe(GROUND_SUPPORT_ID)
+
+    const generatedSlab = SlabNode.parse({
+      polygon: [
+        [-2, -2],
+        [2, -2],
+        [2, 2],
+        [-2, 2],
+      ],
+      elevation: 2.45,
+      autoFromWalls: true,
+      parentId: LEVEL_ID,
+    })
+    spatialGridManager.handleNodeCreated(generatedSlab as AnyNode, LEVEL_ID)
+
+    expect(
+      getFloorPlacedElevation({
+        node: pinnedSlope,
+        nodes: {
+          ...useScene.getState().nodes,
+          [generatedSlab.id]: generatedSlab as AnyNode,
+        },
+        position: pinnedSlope.position,
+        rotation: [0, pinnedSlope.rotation, 0],
+      }),
+    ).toBe(0)
+  })
+
   test('a flat-ground draft (no sculpted terrain) commits plane-bound', () => {
     // Pointing at bare ground freezes a GROUND construction plane at 0. With
     // no terrain field in the scene that plane is just the backdrop — none of
@@ -248,6 +436,136 @@ describe('createWallOnCurrentLevel', () => {
     expect(created?.supportSlabId).not.toBe(GROUND_SUPPORT_ID)
   })
 
+  test('a fresh-scene wall started on a slab node-top elects that slab plane-bound', () => {
+    const slab = SlabNode.parse({
+      id: 'slab_fresh_floor',
+      parentId: LEVEL_ID,
+      polygon: [
+        [-1, -1],
+        [5, -1],
+        [5, 5],
+        [-1, 5],
+      ],
+      elevation: 0.05,
+      thickness: 0.05,
+    })
+    seedLevel([], [slab])
+    spatialGridManager.clear()
+    spatialGridManager.handleNodeCreated(slab as AnyNode, LEVEL_ID)
+
+    const created = createWallOnCurrentLevel([2, 2], [3, 2], {
+      supportCap: 0.05,
+      preferredSupportSlabId: null,
+      constructionElevation: 0.05,
+      constructionHeight: 2.5,
+      constructionSourceNodeId: slab.id,
+      flatConstructionBase: true,
+    })
+
+    expect(created).not.toBeNull()
+    expect(created?.supportSlabId).toBeUndefined()
+    expect(created?.height).toBeUndefined()
+    expect(created?.supportOffset).toBeUndefined()
+    const support = spatialGridManager.getSlabSupportForWall(
+      LEVEL_ID,
+      created!.start,
+      created!.end,
+      created!.curveOffset,
+      created!.thickness,
+      created!.supportSlabId,
+    )
+    expect(support.electedSlabId).toBe(slab.id)
+    expect(support.elevation).toBeCloseTo(0.05)
+  })
+
+  test('a direct slab source does not pin a cross-slab wall away from the higher majority support', () => {
+    const sourceSlab = SlabNode.parse({
+      id: 'slab_source_low',
+      parentId: LEVEL_ID,
+      polygon: [
+        [-0.1, -1],
+        [0.1, -1],
+        [0.1, 1],
+        [-0.1, 1],
+      ],
+      elevation: 0.1,
+      thickness: 0.05,
+    })
+    const majoritySlab = SlabNode.parse({
+      id: 'slab_majority_high',
+      parentId: LEVEL_ID,
+      polygon: [
+        [0.1, -1],
+        [4.1, -1],
+        [4.1, 1],
+        [0.1, 1],
+      ],
+      elevation: 0.6,
+      thickness: 0.1,
+    })
+    seedLevel([], [sourceSlab, majoritySlab])
+    spatialGridManager.clear()
+    spatialGridManager.handleNodeCreated(sourceSlab as AnyNode, LEVEL_ID)
+    spatialGridManager.handleNodeCreated(majoritySlab as AnyNode, LEVEL_ID)
+
+    const created = createWallOnCurrentLevel([0, 0], [4, 0], {
+      supportCap: 0.6,
+      preferredSupportSlabId: null,
+      constructionElevation: 0.1,
+      constructionHeight: 2.5,
+      constructionSourceNodeId: sourceSlab.id,
+      flatConstructionBase: true,
+    })
+
+    expect(created?.supportSlabId).toBe(majoritySlab.id)
+    expect(created?.height).toBeUndefined()
+    expect(created?.supportOffset).toBeUndefined()
+  })
+
+  test('a grazing direct slab source does not override the commit elevation cap', () => {
+    const sourceSlab = SlabNode.parse({
+      id: 'slab_source_high',
+      parentId: LEVEL_ID,
+      polygon: [
+        [-0.1, -1],
+        [0.1, -1],
+        [0.1, 1],
+        [-0.1, 1],
+      ],
+      elevation: 0.6,
+      thickness: 0.1,
+    })
+    const cappedSlab = SlabNode.parse({
+      id: 'slab_capped_low',
+      parentId: LEVEL_ID,
+      polygon: [
+        [-0.1, -1],
+        [4.1, -1],
+        [4.1, 1],
+        [-0.1, 1],
+      ],
+      elevation: 0.1,
+      thickness: 0.05,
+    })
+    seedLevel([], [sourceSlab, cappedSlab])
+    spatialGridManager.clear()
+    spatialGridManager.handleNodeCreated(sourceSlab as AnyNode, LEVEL_ID)
+    spatialGridManager.handleNodeCreated(cappedSlab as AnyNode, LEVEL_ID)
+
+    const created = createWallOnCurrentLevel([0, 0], [4, 0], {
+      supportCap: 0.1,
+      preferredSupportSlabId: null,
+      constructionElevation: 0.6,
+      constructionHeight: 2.5,
+      constructionSourceNodeId: sourceSlab.id,
+      flatConstructionBase: true,
+    })
+
+    expect(created?.supportSlabId).toBe(cappedSlab.id)
+    expect(created?.height).toBeUndefined()
+    expect(created?.supportOffset).toBeUndefined()
+  })
+
   test('a non-ground draft never freezes the ghost height, even at a raised plane', () => {
     const created = createWallOnCurrentLevel([2, 2], [3, 2], {
       supportCap: 1.2,

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

@@ -1,17 +1,13 @@
 import {
-  type AnyNode,
   type AnyNodeId,
   DEFAULT_ANGLE_STEP,
-  DEFAULT_LEVEL_HEIGHT,
-  GROUND_SUPPORT_ID,
   planWallInsertion,
   planWallSplitAtPoint,
-  resolveWallSupportSlabPatch,
+  resolveWallConstruction,
   runAsSingleSceneHistoryStep,
   snapPointAlongAngleRay,
-  spatialGridManager,
-  terrainSupportLift,
   useScene,
+  type WallConstructionOptions,
   type WallNode,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
@@ -209,41 +205,6 @@ 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,
@@ -269,82 +230,30 @@ export function createWallOnCurrentLevel(
     if (!result.ok) return null
     const { plan } = result
 
-    applyNodeChanges(plan.changes)
-    const committedNodes = useScene.getState().nodes
-    const supportUpdates = plan.insertedWalls.flatMap((wall) => {
-      const createdWall = committedNodes[wall.id]
-      if (createdWall?.type !== 'wall') return []
-      const terrainBase = terrainSupportLift(
-        committedNodes,
-        currentLevelId,
-        createdWall.start[0],
-        createdWall.start[1],
-      )
-      // A ground-preferred draft is the terrain exception only while sculpted
-      // terrain actually supports this storey. On flat ground the ground plane
-      // is just the backdrop the chain started from: drop the draft options so
-      // the wall commits plane-bound — no stamped height, no persisted ground
-      // host, no election cap at the draft plane.
-      const wallOptions =
-        options?.preferredSupportSlabId === GROUND_SUPPORT_ID && terrainBase == null
-          ? undefined
-          : options
-      const preferredSupportSlabId =
-        wallOptions?.preferredSupportSlabId ??
-        (wallOptions?.constructionElevation != null && terrainBase != null
-          ? GROUND_SUPPORT_ID
-          : null)
-      const supportPatch = resolveWallSupportSlabPatch(createdWall, committedNodes, {
-        maxElevation: wallOptions?.supportCap ?? null,
-        preferredSlabId: preferredSupportSlabId,
-      })
-      const supportSlabId = supportPatch.supportSlabId
-      const sourceSupport = spatialGridManager.getSlabSupportForWall(
-        currentLevelId,
-        createdWall.start,
-        createdWall.end,
-        createdWall.curveOffset,
-        createdWall.thickness,
-        supportSlabId,
-        wallOptions?.supportCap ?? null,
-      )
-      // Freezing the draft plane into the node (explicit height + offset from
-      // the elected support) is the terrain exception only: a ground-drafted
-      // chain keeps one construction plane and a fixed body height while
-      // sculpting moves the ground. Every other wall stays plane-bound —
-      // height absent, top at the storey plane, base re-elected from slab
-      // support — so a wall merely started on a slab or deck must never have
-      // the ghost height stamped onto it.
-      const groundDraft = preferredSupportSlabId === GROUND_SUPPORT_ID
-      const supportOffset =
-        groundDraft && wallOptions?.constructionElevation != null
-          ? wallOptions.constructionElevation - sourceSupport.elevation
-          : undefined
-      const preserveDraftHeight =
-        groundDraft &&
-        createdWall.height == null &&
-        wallOptions?.constructionHeight != null &&
-        wallOptions.constructionElevation != null
-      return [
-        {
-          id: createdWall.id,
-          data: {
-            ...supportPatch,
-            height: preserveDraftHeight
-              ? (wallOptions?.constructionHeight ?? createdWall.height)
-              : createdWall.height,
-            supportOffset:
-              supportOffset != null && Math.abs(supportOffset) > 1e-6 ? supportOffset : undefined,
-          },
-        },
-      ]
+    const construction = resolveWallConstruction(nodes, currentLevelId, plan.insertedWalls, options)
+    const finalizedWalls = construction.walls
+    const finalizedWallsById = new Map(finalizedWalls.map((wall) => [wall.id, wall]))
+    const sourceUpdate = construction.sourceSupportUpdate
+    const sourceAlreadyUpdated = sourceUpdate
+      ? plan.changes.update.some((operation) => operation.id === sourceUpdate.id)
+      : false
+    applyNodeChanges({
+      ...plan.changes,
+      update: plan.changes.update
+        .map((operation) =>
+          sourceUpdate?.id === operation.id
+            ? { ...operation, data: { ...operation.data, ...sourceUpdate.data } }
+            : operation,
+        )
+        .concat(sourceUpdate && !sourceAlreadyUpdated ? [sourceUpdate] : []),
+      create: plan.changes.create.map((operation) => ({
+        ...operation,
+        node: finalizedWallsById.get(operation.node.id as WallNode['id']) ?? operation.node,
+      })),
     })
-    if (supportUpdates.length > 0) {
-      useScene.getState().updateNodes(supportUpdates)
-    }
     sfxEmitter.emit('sfx:structure-build')
 
-    const terminalWall = plan.insertedWalls.at(-1)!
+    const terminalWall = finalizedWalls.at(-1)!
     const committedWall = useScene.getState().nodes[plan.terminalWallId]
     return committedWall?.type === 'wall' ? committedWall : terminalWall
   })

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

@@ -54,7 +54,7 @@ export function ControlModes() {
   const mode = useEditor((state) => state.mode)
   const phase = useEditor((state) => state.phase)
   const selectionTool = useEditor((state) => state.floorplanSelectionTool)
-  const setMode = useEditor((state) => state.setMode)
+  const armToolMode = useEditor((state) => state.armToolMode)
   const setPhase = useEditor((state) => state.setPhase)
   const setStructureLayer = useEditor((state) => state.setStructureLayer)
   const setSelectionTool = useEditor((state) => state.setFloorplanSelectionTool)
@@ -82,21 +82,21 @@ export function ControlModes() {
     }
 
     if (id === 'select') {
-      setMode('select')
+      armToolMode({ mode: 'select' })
       setSelectionTool('click')
     } else if (id === 'box-select') {
-      setMode('select')
+      armToolMode({ mode: 'select' })
       setSelectionTool('marquee')
     } else if (id === 'zone') {
       if (getIsActive('zone')) {
-        setMode('select')
+        armToolMode({ mode: 'select' })
       } else {
         setPhase('structure')
         setStructureLayer('zones')
-        setMode('build')
+        armToolMode({ mode: 'build', tool: 'zone' })
       }
     } else {
-      setMode(id)
+      armToolMode({ mode: id })
     }
   }
 
@@ -118,6 +118,9 @@ export function ControlModes() {
                 isImageMode && isActive && 'bg-white/10 hover:bg-white/10',
                 isImageMode && !isActive && 'hover:bg-white/5',
               )}
+              // A static hook for a host app that wants to point a first-run
+              // tour at this button. Nothing here reads it.
+              data-guide-target={c.id === 'select' ? 'mode-select' : undefined}
               label={c.label}
               onClick={() => handleClick(c.id)}
               shortcut={c.shortcut}

package/src/components/ui/action-menu/index.tsx

@@ -1,10 +1,12 @@
 'use client'
 
+import { useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { motion } from 'motion/react'
 import { TooltipProvider } from './../../../components/ui/primitives/tooltip'
 import { useIsMobile } from './../../../hooks/use-mobile'
 import { useReducedMotion } from './../../../hooks/use-reduced-motion'
+import { shouldShowEditingControls } from './../../../lib/interaction/overlay-policy'
 import { cn } from './../../../lib/utils'
 import useEditor from './../../../store/use-editor'
 import { CameraActions } from './camera-actions'
@@ -18,6 +20,7 @@ const MOBILE_BOTTOM_OFFSET = 24
 
 export function ActionMenu({ className }: { className?: string }) {
   const isMobile = useIsMobile()
+  const readOnly = useScene((s) => s.readOnly)
   const hasSelectionOnMobile = useViewer((s) => isMobile && s.selection.selectedIds.length > 0)
   const hasReferenceOnMobile = useEditor((s) => isMobile && Boolean(s.selectedReferenceId))
   const CONTEXTUAL_TABS = new Set(['ai', 'items', 'studio'])
@@ -31,7 +34,14 @@ export function ActionMenu({ className }: { className?: string }) {
   // Also hide on Chat / Items / Studio tabs; those are contextual workflows
   // (composing / picking furniture / generating renders) where the build
   // menu is irrelevant.
-  if (hasSelectionOnMobile || hasReferenceOnMobile || isContextualPanelOnMobile) return null
+  if (
+    !shouldShowEditingControls(readOnly) ||
+    hasSelectionOnMobile ||
+    hasReferenceOnMobile ||
+    isContextualPanelOnMobile
+  ) {
+    return null
+  }
 
   const transition = reducedMotion
     ? { duration: 0 }

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

@@ -49,10 +49,9 @@ export function EditorCommands() {
   const { navigateTo, setInputValue, setOpen } = useCommandPalette()
 
   const setPhase = useEditor((s) => s.setPhase)
-  const setMode = useEditor((s) => s.setMode)
-  const setTool = useEditor((s) => s.setTool)
+  const armToolMode = useEditor((s) => s.armToolMode)
+  const armMaterialPaint = useEditor((s) => s.armMaterialPaint)
   const setStructureLayer = useEditor((s) => s.setStructureLayer)
-  const primeMaterialPaintFromSelection = useEditor((s) => s.primeMaterialPaintFromSelection)
   const isPreviewMode = useEditor((s) => s.isPreviewMode)
   const setPreviewMode = useEditor((s) => s.setPreviewMode)
 
@@ -68,9 +67,9 @@ export function EditorCommands() {
     const activateTool = (tool: StructureTool) => {
       run(() => {
         setPhase('structure')
-        setMode('build')
         if (tool === 'zone') setStructureLayer('zones')
-        setTool(tool)
+        else setStructureLayer('elements')
+        armToolMode({ mode: 'build', tool })
       })
     }
 
@@ -163,10 +162,9 @@ export function EditorCommands() {
         shortcut: ['P'],
         execute: () =>
           run(() => {
-            primeMaterialPaintFromSelection()
             setPhase('structure')
             setStructureLayer('elements')
-            setMode('material-paint')
+            armMaterialPaint()
           }),
       },
       {
@@ -176,9 +174,8 @@ export function EditorCommands() {
         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')),
+        // The ToolMode transition moves to the site phase itself.
+        execute: () => run(() => armToolMode({ mode: 'terrain-sculpt' })),
       },
 
       // ── Levels ───────────────────────────────────────────────────────────
@@ -428,8 +425,8 @@ export function EditorCommands() {
     setInputValue,
     setOpen,
     setPhase,
-    setMode,
-    setTool,
+    armToolMode,
+    armMaterialPaint,
     setStructureLayer,
     isPreviewMode,
     setPreviewMode,

package/src/components/ui/command-palette/index.tsx

@@ -2,7 +2,7 @@
 
 import type { AnyNodeId, LevelNode } from '@pascal-app/core'
 import { useScene } from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
+import { markPerfAction, useViewer } from '@pascal-app/viewer'
 import { Command, useCommandState } from 'cmdk'
 import { ChevronRight, Search } from 'lucide-react'
 import type { ReactNode } from 'react'
@@ -408,7 +408,12 @@ export function CommandPalette({ emptyAction }: { emptyAction?: CommandPaletteEm
                       key={level.id}
                       label={getLevelDisplayName(level)}
                       onSelect={() =>
-                        run(() => useViewer.getState().setSelection({ levelId: level.id }))
+                        run(() => {
+                          if (level.id !== useViewer.getState().selection.levelId) {
+                            markPerfAction('level-switch', level.id)
+                          }
+                          useViewer.getState().setSelection({ levelId: level.id })
+                        })
                       }
                     />
                   ))}