@pascal-app/editor 0.9.1 → 0.9.2

package/src/components/tools/site/site-boundary-editor.tsx

@@ -3,12 +3,21 @@ import { SCENE_LAYER } from '@pascal-app/viewer'
 import { useGLTF } from '@react-three/drei/core/Gltf'
 import { useFrame } from '@react-three/fiber'
 import { Suspense, useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { Color, CylinderGeometry, DoubleSide, type Mesh, type Object3D, RingGeometry } from 'three'
+import {
+  Color,
+  CylinderGeometry,
+  DoubleSide,
+  type Group,
+  type Mesh,
+  type Object3D,
+  RingGeometry,
+} from 'three'
 import { MeshBasicNodeMaterial } from 'three/webgpu'
 import { EDITOR_LAYER } from '../../../lib/constants'
 import { sfxEmitter } from '../../../lib/sfx-bus'
 import { SITE_BOUNDARY_DRAG_LABEL } from '../../../lib/site-boundary'
 import useEditor, { selectSiteFloorplanContext } from '../../../store/use-editor'
+import useInteractionScope from '../../../store/use-interaction-scope'
 import {
   ARROW_COLOR,
   ARROW_HOVER_COLOR,
@@ -38,6 +47,7 @@ const SITE_FLAG_HALO_COLOR = '#6366f1'
 
 type TintableMaterial = {
   color?: Color
+  depthTest: boolean
   depthWrite: boolean
   opacity: number
   needsUpdate: boolean
@@ -69,10 +79,9 @@ function SiteFlagModel({
         mesh.frustumCulled = false
         mesh.raycast = NO_RAYCAST
         mesh.receiveShadow = false
-        mesh.renderOrder = 1010
         mesh.material = new MeshBasicNodeMaterial({
           color: new Color(ARROW_COLOR),
-          depthTest: false,
+          depthTest: true,
           depthWrite: opacity >= 0.999,
           opacity,
           transparent: opacity < 0.999,
@@ -93,6 +102,7 @@ function SiteFlagModel({
 
         for (const material of materials as Array<MeshBasicNodeMaterial & TintableMaterial>) {
           material.color?.copy(color)
+          material.depthTest = true
           material.opacity = opacity
           material.transparent = opacity < 0.999
           material.depthWrite = opacity >= 0.999
@@ -217,11 +227,23 @@ function SiteFlagFallback({
     <group position={[0, SITE_FLAG_BASE_Y + (active ? SITE_FLAG_ACTIVE_LIFT : 0), 0]}>
       <mesh layers={SCENE_LAYER} position={[0, 0.16, 0]} raycast={NO_RAYCAST}>
         <cylinderGeometry args={[0.11, 0.16, 0.32, 24]} />
-        <meshBasicMaterial color={color} depthTest={false} opacity={opacity} transparent />
+        <meshBasicMaterial
+          color={color}
+          depthTest
+          depthWrite={opacity >= 0.999}
+          opacity={opacity}
+          transparent={opacity < 0.999}
+        />
       </mesh>
       <mesh layers={SCENE_LAYER} position={[0, 0.34, 0]} raycast={NO_RAYCAST}>
         <cylinderGeometry args={[0.04, 0.11, 0.14, 24]} />
-        <meshBasicMaterial color={color} depthTest={false} opacity={opacity} transparent />
+        <meshBasicMaterial
+          color={color}
+          depthTest
+          depthWrite={opacity >= 0.999}
+          opacity={opacity}
+          transparent={opacity < 0.999}
+        />
       </mesh>
     </group>
   )
@@ -355,14 +377,20 @@ export const SiteBoundaryEditor: React.FC = () => {
 
       if (!siteId) return
 
-      const editor = useEditor.getState()
       if (isDragging) {
-        editor.setActiveHandleDrag({ nodeId: siteId, label: SITE_BOUNDARY_DRAG_LABEL })
-      } else if (
-        editor.activeHandleDrag?.nodeId === siteId &&
-        editor.activeHandleDrag.label === SITE_BOUNDARY_DRAG_LABEL
-      ) {
-        editor.setActiveHandleDrag(null)
+        useInteractionScope
+          .getState()
+          .begin({ kind: 'handle-drag', nodeId: siteId, handle: SITE_BOUNDARY_DRAG_LABEL })
+      } else {
+        const scope = useInteractionScope.getState().scope
+        const activeHandleDrag =
+          scope.kind === 'handle-drag' ? { nodeId: scope.nodeId, label: scope.handle } : null
+        if (
+          activeHandleDrag?.nodeId === siteId &&
+          activeHandleDrag.label === SITE_BOUNDARY_DRAG_LABEL
+        ) {
+          useInteractionScope.getState().endIf((sc) => sc.kind === 'handle-drag')
+        }
       }
 
       if (!isDragging) {
@@ -375,12 +403,14 @@ export const SiteBoundaryEditor: React.FC = () => {
   useEffect(
     () => () => {
       if (!siteId) return
-      const editor = useEditor.getState()
+      const scope = useInteractionScope.getState().scope
+      const activeHandleDrag =
+        scope.kind === 'handle-drag' ? { nodeId: scope.nodeId, label: scope.handle } : null
       if (
-        editor.activeHandleDrag?.nodeId === siteId &&
-        editor.activeHandleDrag.label === SITE_BOUNDARY_DRAG_LABEL
+        activeHandleDrag?.nodeId === siteId &&
+        activeHandleDrag.label === SITE_BOUNDARY_DRAG_LABEL
       ) {
-        editor.setActiveHandleDrag(null)
+        useInteractionScope.getState().endIf((sc) => sc.kind === 'handle-drag')
       }
       useLiveNodeOverrides.getState().clearFields(siteId, ['polygon'])
       isDraggingSiteBoundaryRef.current = false
@@ -394,6 +424,26 @@ export const SiteBoundaryEditor: React.FC = () => {
     }
   }, [isSiteEditing, siteId])
 
+  // The flag models render on SCENE_LAYER (scene-depth occlusion), so unlike
+  // EDITOR_LAYER affordances the thumbnail camera can't filter them — hide
+  // them around captures (preset/snapshot/auto-save thumbnails), same as
+  // `handle-arrow.tsx`.
+  const handlesRootRef = useRef<Group>(null)
+  useEffect(() => {
+    const hideForCapture = () => {
+      if (handlesRootRef.current) handlesRootRef.current.visible = false
+    }
+    const restoreAfterCapture = () => {
+      if (handlesRootRef.current) handlesRootRef.current.visible = true
+    }
+    emitter.on('thumbnail:before-capture', hideForCapture)
+    emitter.on('thumbnail:after-capture', restoreAfterCapture)
+    return () => {
+      emitter.off('thumbnail:before-capture', hideForCapture)
+      emitter.off('thumbnail:after-capture', restoreAfterCapture)
+    }
+  }, [])
+
   const activateSiteEditing = useCallback(() => {
     isDraggingSiteBoundaryRef.current = true
     setIsDraggingSiteBoundary(true)
@@ -470,25 +520,27 @@ export const SiteBoundaryEditor: React.FC = () => {
   if (!showSiteHandles) return null
 
   return (
-    <PolygonEditor
-      color={isSiteBoundaryHighlighted ? ARROW_COLOR : '#10b981'}
-      minVertices={3}
-      onBeforeVertexDrag={activateSiteEditing}
-      onDragCommit={() => {
-        sfxEmitter.emit('sfx:item-place')
-        exitSiteEditing()
-      }}
-      onDragStart={() => sfxEmitter.emit('sfx:item-pick')}
-      onDragStateChange={handleSiteBoundaryDragChange}
-      onMidpointHoverChange={setHoveredMidpoint}
-      onPolygonChange={handlePolygonChange}
-      onPolygonPreview={handlePolygonPreview}
-      onVertexHoverChange={setHoveredVertex}
-      polygon={displayPolygon}
-      renderMidpointHandle={renderSiteFlagMidpoint}
-      renderVertexHandle={renderSiteFlagVertex}
-      showBorderLine={isSiteBoundaryHighlighted}
-      showMidpointHandles={showSiteHandles}
-    />
+    <group ref={handlesRootRef}>
+      <PolygonEditor
+        color={isSiteBoundaryHighlighted ? ARROW_COLOR : '#10b981'}
+        minVertices={3}
+        onBeforeVertexDrag={activateSiteEditing}
+        onDragCommit={() => {
+          sfxEmitter.emit('sfx:item-place')
+          exitSiteEditing()
+        }}
+        onDragStart={() => sfxEmitter.emit('sfx:item-pick')}
+        onDragStateChange={handleSiteBoundaryDragChange}
+        onMidpointHoverChange={setHoveredMidpoint}
+        onPolygonChange={handlePolygonChange}
+        onPolygonPreview={handlePolygonPreview}
+        onVertexHoverChange={setHoveredVertex}
+        polygon={displayPolygon}
+        renderMidpointHandle={renderSiteFlagMidpoint}
+        renderVertexHandle={renderSiteFlagVertex}
+        showBorderLine={isSiteBoundaryHighlighted}
+        showMidpointHandles={showSiteHandles}
+      />
+    </group>
   )
 }

package/src/components/tools/stair/stair-defaults.ts

@@ -6,6 +6,7 @@ export const DEFAULT_STAIR_STEP_COUNT = 10
 export const DEFAULT_STAIR_ATTACHMENT_SIDE = 'front' as const
 export const DEFAULT_STAIR_FILL_TO_FLOOR = true
 export const DEFAULT_STAIR_THICKNESS = 0.25
+export const DEFAULT_STAIR_OPENING_OFFSET = 0
 export const DEFAULT_CURVED_STAIR_INNER_RADIUS = 0.9
 export const DEFAULT_CURVED_STAIR_SWEEP_ANGLE = Math.PI / 2
 export const DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE = (400 * Math.PI) / 180

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

@@ -14,7 +14,6 @@ import {
   syncAutoStairOpenings,
   useScene,
 } from '@pascal-app/core'
-import { useAlignmentGuides } from '@pascal-app/editor'
 import { useViewer } from '@pascal-app/viewer'
 import { useEffect, useMemo, useRef } from 'react'
 import * as THREE from 'three'
@@ -23,6 +22,15 @@ import {
   resolveStairDestinationLevel,
   resolveStairPlacementLevelId,
 } from '../../../lib/stair-levels'
+
+import useAlignmentGuides from '../../../store/use-alignment-guides'
+import useEditor, {
+  isAlignmentGuideActive,
+  isGridSnapActive,
+  isMagneticSnapActive,
+} from '../../../store/use-editor'
+
+import useFacingPose from '../../../store/use-facing-pose'
 import { CursorSphere } from '../shared/cursor-sphere'
 import { getFloorStackPreviewPosition } from '../shared/floor-stack-preview'
 import {
@@ -36,6 +44,7 @@ import {
   DEFAULT_STAIR_FILL_TO_FLOOR,
   DEFAULT_STAIR_HEIGHT,
   DEFAULT_STAIR_LENGTH,
+  DEFAULT_STAIR_OPENING_OFFSET,
   DEFAULT_STAIR_RAILING_HEIGHT,
   DEFAULT_STAIR_RAILING_MODE,
   DEFAULT_STAIR_STEP_COUNT,
@@ -138,7 +147,7 @@ function createDefaultStairNode({
     fromLevelId: levelId,
     toLevelId: nextLevelId,
     slabOpeningMode: 'destination',
-    openingOffset: 0.08,
+    openingOffset: DEFAULT_STAIR_OPENING_OFFSET,
     width: DEFAULT_STAIR_WIDTH,
     totalRise: DEFAULT_STAIR_HEIGHT,
     stepCount: DEFAULT_STAIR_STEP_COUNT,
@@ -263,7 +272,19 @@ export const StairTool: React.FC = () => {
       return { placementLevelId, previewNodes, stair }
     }
 
+    // The preview rebuild (full-scene copy + destination-level resolution +
+    // auto-opening CSG) is expensive; `grid:move` fires it every pointer event
+    // but the placed position is grid-snapped, so within a cell every rebuild
+    // is identical. Dedupe on the snapped position + rotation so we rebuild
+    // only when the staircase would actually land somewhere new — this is the
+    // difference between a smooth and a stuttering stair tool (the elevator is
+    // cheap because it has no opening sync).
+    let lastPreviewKey: string | null = null
+
     const applyDraftPreview = (position: [number, number, number], rotation: number) => {
+      const key = `${position[0].toFixed(3)},${position[2].toFixed(3)},${rotation.toFixed(4)}`
+      if (key === lastPreviewKey) return
+      lastPreviewKey = key
       const preview = buildPreviewScene(position, rotation)
       const visualPosition = preview
         ? getFloorStackPreviewPosition({
@@ -287,6 +308,19 @@ export const StairTool: React.FC = () => {
         previewRef.current.rotation.y = rotation
       }
 
+      // Forward-facing triangle (editor-side overlay). The run ascends along
+      // local +Z from the entry at z≈0; the stair's front is the -Z entry side,
+      // so `reversed` points the triangle out of the entry (where you approach
+      // from), sitting just before it — not inside the footprint or at the
+      // elevated far end. Centre is the footprint mid-run (origin is the entry).
+      useFacingPose.getState().set({
+        position: visualPosition,
+        rotationY: rotation,
+        depth: DEFAULT_STAIR_LENGTH,
+        center: [0, DEFAULT_STAIR_LENGTH / 2],
+        reversed: true,
+      })
+
       if (!preview) {
         openingPreview.clear()
         return
@@ -319,13 +353,16 @@ export const StairTool: React.FC = () => {
     // The probe is the RAW cursor, not the grid-snapped point: resolving
     // against the grid point would only catch anchors that happen to sit near
     // a grid line. Matched axes use the raw probe + snap delta; unmatched axes
-    // keep the normal grid snap. Alt bypasses.
+    // keep the normal grid snap. Guides are published in every snapping mode
+    // (including Off); the magnetic pull toward them (applySnap) applies only in
+    // 'lines' mode.
     const alignPoint = (
       gridX: number,
       gridZ: number,
       rawX: number,
       rawZ: number,
       bypass: boolean,
+      applySnap: boolean,
     ): [number, number] => {
       if (bypass || alignmentCandidates.length === 0) {
         useAlignmentGuides.getState().clear()
@@ -336,6 +373,10 @@ export const StairTool: React.FC = () => {
         useAlignmentGuides.getState().clear()
         return [gridX, gridZ]
       }
+      if (!applySnap) {
+        useAlignmentGuides.getState().set(ar.guides)
+        return [gridX, gridZ]
+      }
       let x = gridX
       let z = gridZ
       if (ar.snap) {
@@ -348,18 +389,27 @@ export const StairTool: React.FC = () => {
     }
 
     const onGridMove = (event: GridEvent) => {
+      // Grid snap follows the global mode (live step so the HUD chip is
+      // honest); Off keeps the raw cursor. Shift cycles the mode centrally.
+      const step = useEditor.getState().gridSnapStep
       const [gridX, gridZ] = alignPoint(
-        Math.round(event.localPosition[0] * 2) / 2,
-        Math.round(event.localPosition[2] * 2) / 2,
+        isGridSnapActive()
+          ? Math.round(event.localPosition[0] / step) * step
+          : event.localPosition[0],
+        isGridSnapActive()
+          ? Math.round(event.localPosition[2] / step) * step
+          : event.localPosition[2],
         event.localPosition[0],
         event.localPosition[2],
-        event.nativeEvent?.altKey === true,
+        !isAlignmentGuideActive(),
+        isMagneticSnapActive(),
       )
       const position: [number, number, number] = [gridX, 0, gridZ]
       lastCanonicalPositionRef.current = position
       applyDraftPreview(position, rotationRef.current)
 
       if (
+        (isGridSnapActive() || isMagneticSnapActive()) &&
         previousGridPosRef.current &&
         (gridX !== previousGridPosRef.current[0] || gridZ !== previousGridPosRef.current[1])
       ) {
@@ -370,12 +420,18 @@ export const StairTool: React.FC = () => {
     }
 
     const getAlignedGridPosition = (event: GridEvent): [number, number, number] => {
+      const step = useEditor.getState().gridSnapStep
       const [gridX, gridZ] = alignPoint(
-        Math.round(event.localPosition[0] * 2) / 2,
-        Math.round(event.localPosition[2] * 2) / 2,
+        isGridSnapActive()
+          ? Math.round(event.localPosition[0] / step) * step
+          : event.localPosition[0],
+        isGridSnapActive()
+          ? Math.round(event.localPosition[2] / step) * step
+          : event.localPosition[2],
         event.localPosition[0],
         event.localPosition[2],
-        event.nativeEvent?.altKey === true,
+        !isAlignmentGuideActive(),
+        isMagneticSnapActive(),
       )
       return [gridX, 0, gridZ]
     }
@@ -395,8 +451,20 @@ export const StairTool: React.FC = () => {
 
       commitStairPlacement(currentLevelId, position, rotationRef.current)
       openingPreview.clear()
-      alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, '', currentLevelId)
+      // Commit cleared the opening preview, so force the next hover (even on the
+      // same cell) to rebuild rather than dedupe against the just-placed key.
+      lastPreviewKey = null
       useAlignmentGuides.getState().clear()
+
+      // Single by default; the C-toggle ('point' context, shared with every
+      // other placement tool) opts into placing more. On single, drop the tool
+      // and the facing triangle so we fall back to select after one stair.
+      if (useEditor.getState().getContinuation('point') === 'repeat') {
+        alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, '', currentLevelId)
+      } else {
+        useFacingPose.getState().clear()
+        useEditor.getState().setTool(null)
+      }
     }
 
     const onKeyDown = (event: KeyboardEvent) => {
@@ -441,6 +509,7 @@ export const StairTool: React.FC = () => {
       window.removeEventListener('keydown', onKeyDown)
       useAlignmentGuides.getState().clear()
       openingPreview.clear()
+      useFacingPose.getState().clear()
     }
   }, [currentLevelId])
 
@@ -448,7 +517,9 @@ export const StairTool: React.FC = () => {
     <group>
       <CursorSphere ref={cursorRef} />
 
-      {/* 3D ghost preview — position/rotation updated imperatively */}
+      {/* 3D ghost preview — position/rotation updated imperatively. The
+          forward-facing triangle is drawn by the editor-side overlay from the
+          pose published in `applyDraftPreview`. */}
       <group ref={previewRef}>
         <mesh castShadow geometry={previewGeometry}>
           <meshStandardMaterial color="#818cf8" depthWrite={false} opacity={0.35} transparent />

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

@@ -2,19 +2,32 @@ import {
   type AnyNodeId,
   type BuildingNode,
   type CeilingNode,
+  type FenceNode,
   nodeRegistry,
   type SlabNode,
   useScene,
+  type WallNode,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
-import { type ComponentType, lazy, Suspense } from 'react'
+import { type ComponentType, lazy, Suspense, useMemo } from 'react'
 import useEditor, { type Phase, type Tool } from '../../store/use-editor'
+import {
+  useControlPointReshape,
+  useEditingHole,
+  useEndpointReshape,
+  useIsCurveReshape,
+  useMovingNode,
+  useReshapingNode,
+  useTangentReshape,
+} from '../../store/use-interaction-scope'
 import { Alignment3DGuideLayer } from '../editor/alignment-3d-guide-layer'
+import { OpeningGuides3DLayer } from '../editor/opening-guides-3d-layer'
 import { WallSnapBeaconLayer } from '../editor/wall-snap-beacon-layer'
 import { ElevatorTool } from './elevator/elevator-tool'
 import { MoveTool } from './item/move-tool'
 import { RoofTool } from './roof/roof-tool'
 import { getRegistryAffordanceTool } from './shared/affordance-dispatch'
+import { FacingPoseIndicator } from './shared/facing-pose-indicator'
 import { SiteBoundaryEditor } from './site/site-boundary-editor'
 import { StairTool } from './stair/stair-tool'
 import { ZoneBoundaryEditor } from './zone/zone-boundary-editor'
@@ -54,12 +67,37 @@ export const ToolManager: React.FC = () => {
   const phase = useEditor((state) => state.phase)
   const mode = useEditor((state) => state.mode)
   const tool = useEditor((state) => state.tool)
-  const movingNode = useEditor((state) => state.movingNode)
-  const movingWallEndpoint = useEditor((state) => state.movingWallEndpoint)
-  const movingFenceEndpoint = useEditor((state) => state.movingFenceEndpoint)
-  const curvingWall = useEditor((state) => state.curvingWall)
-  const curvingFence = useEditor((state) => state.curvingFence)
-  const editingHole = useEditor((state) => state.editingHole)
+  const movingNode = useMovingNode()
+  const movingNodeOrigin = useEditor((state) => state.movingNodeOrigin)
+  const endpointReshape = useEndpointReshape()
+  const controlPointReshape = useControlPointReshape()
+  const tangentReshape = useTangentReshape()
+  const isCurveReshape = useIsCurveReshape()
+  const reshapingNode = useReshapingNode()
+  // The endpoint affordance tool's `target` is kind-specific
+  // (`{ wall | fence, endpoint }`); rebuild it from the (frozen) reshaped node +
+  // the scope's endpoint. Memoised so it stays referentially stable across the
+  // scene-write re-renders during the drag — otherwise a fresh object each frame
+  // re-fires the tool's setup effect (endpoint drag would loop / freeze).
+  const endpointTarget = useMemo(() => {
+    if (!(endpointReshape && reshapingNode)) return null
+    return reshapingNode.type === 'fence'
+      ? { fence: reshapingNode as FenceNode, endpoint: endpointReshape.endpoint }
+      : { wall: reshapingNode as WallNode, endpoint: endpointReshape.endpoint }
+  }, [endpointReshape, reshapingNode])
+  const controlPointTarget = useMemo(() => {
+    if (!(controlPointReshape && reshapingNode?.type === 'fence')) return null
+    return { fence: reshapingNode as FenceNode, index: controlPointReshape.index }
+  }, [controlPointReshape, reshapingNode])
+  const tangentTarget = useMemo(() => {
+    if (!(tangentReshape && reshapingNode?.type === 'fence')) return null
+    return {
+      fence: reshapingNode as FenceNode,
+      index: tangentReshape.index,
+      side: tangentReshape.side,
+    }
+  }, [reshapingNode, tangentReshape])
+  const editingHole = useEditingHole()
   const selectedZoneId = useViewer((state) => state.selection.zoneId)
   const selectedIds = useViewer((state) => state.selection.selectedIds)
   const buildingId = useViewer((state) => state.selection.buildingId)
@@ -94,10 +132,16 @@ export const ToolManager: React.FC = () => {
   // switches to full polygon editing only after a flag activates site mode.
   const showSiteBoundaryEditor = phase === 'site' || mode === 'select'
 
+  // A multi-selection is manipulated as one rigid group (drag / R / T), so
+  // per-node reshape chrome — the slab / ceiling boundary editors' vertex and
+  // edge handles — mounts only for a sole selection.
+  const isSoleSelection = selectedIds.length === 1
+
   // Show slab boundary editor when in structure/select mode with a slab selected (but not editing a hole)
   const showSlabBoundaryEditor =
     phase === 'structure' &&
     mode === 'select' &&
+    isSoleSelection &&
     selectedSlabId !== undefined &&
     !editingSlabHoleIsManual
 
@@ -112,6 +156,7 @@ export const ToolManager: React.FC = () => {
   const showCeilingBoundaryEditor =
     phase === 'structure' &&
     mode === 'select' &&
+    isSoleSelection &&
     selectedCeilingId !== undefined &&
     (!editingHole || editingHole.nodeId !== selectedCeilingId)
 
@@ -133,6 +178,16 @@ export const ToolManager: React.FC = () => {
   // Show build tools when in build mode
   const showBuildTool = mode === 'build' && tool !== null
 
+  // A move initiated from the 2D floor-plan (orange move-dot) is owned end-to-
+  // end by `FloorplanRegistryMoveOverlay`, which marks the origin `'2d'` at
+  // dot-down. Mounting the 3D affordance mover alongside it would adopt the
+  // same node and, on its unmount, restore the adopt-time position — snapping
+  // the committed 2D move back to its start. Gate the 3D mover off for 2D moves
+  // (the scene writes the overlay makes still mirror into the 3D view). A
+  // 3D-initiated move leaves the origin null until its own commit, so this only
+  // suppresses the 3D tool for genuinely 2D-owned moves.
+  const showMover = movingNode != null && movingNodeOrigin !== '2d'
+
   // Registry-first: if the active tool's kind has a NodeDefinition with a
   // tool contribution, the registry-driven tool takes over.
   const RegistryToolComponent = showBuildTool ? getRegistryTool(tool) : null
@@ -162,7 +217,7 @@ export const ToolManager: React.FC = () => {
     <>
       {/* World-space tools: site boundary and building movement operate in world coordinates */}
       {showSiteBoundaryEditor && <SiteBoundaryEditor />}
-      {movingNode?.type === 'building' && (
+      {showMover && movingNode?.type === 'building' && (
         <MoveTool onNodeMoved={handlePlacedNodeSelected} onSpawnMoved={handlePlacedNodeSelected} />
       )}
 
@@ -216,49 +271,48 @@ export const ToolManager: React.FC = () => {
               </Suspense>
             ) : null
           })()}
-        {movingWallEndpoint &&
+        {endpointTarget &&
+          reshapingNode &&
           (() => {
             const RegistryAffordance = getRegistryAffordanceTool(
-              movingWallEndpoint.wall.type,
+              reshapingNode.type,
               'move-endpoint',
             )
             return RegistryAffordance ? (
               <Suspense fallback={null}>
-                <RegistryAffordance target={movingWallEndpoint} />
+                <RegistryAffordance target={endpointTarget} />
               </Suspense>
             ) : null
           })()}
-        {movingFenceEndpoint &&
+        {isCurveReshape &&
+          reshapingNode &&
           (() => {
-            const RegistryAffordance = getRegistryAffordanceTool(
-              movingFenceEndpoint.fence.type,
-              'move-endpoint',
-            )
+            const RegistryAffordance = getRegistryAffordanceTool(reshapingNode.type, 'curve')
             return RegistryAffordance ? (
               <Suspense fallback={null}>
-                <RegistryAffordance target={movingFenceEndpoint} />
+                <RegistryAffordance node={reshapingNode} />
               </Suspense>
             ) : null
           })()}
-        {curvingWall &&
+        {controlPointTarget &&
           (() => {
-            const Registry = getRegistryAffordanceTool(curvingWall.type, 'curve')
-            return Registry ? (
+            const RegistryAffordance = getRegistryAffordanceTool('fence', 'move-control-point')
+            return RegistryAffordance ? (
               <Suspense fallback={null}>
-                <Registry node={curvingWall} />
+                <RegistryAffordance target={controlPointTarget} />
               </Suspense>
             ) : null
           })()}
-        {curvingFence &&
+        {tangentTarget &&
           (() => {
-            const RegistryAffordance = getRegistryAffordanceTool(curvingFence.type, 'curve')
+            const RegistryAffordance = getRegistryAffordanceTool('fence', 'move-tangent')
             return RegistryAffordance ? (
               <Suspense fallback={null}>
-                <RegistryAffordance node={curvingFence} />
+                <RegistryAffordance target={tangentTarget} />
               </Suspense>
             ) : null
           })()}
-        {movingNode && movingNode.type !== 'building' && (
+        {showMover && movingNode.type !== 'building' && (
           <MoveTool
             onNodeMoved={handlePlacedNodeSelected}
             onSpawnMoved={handlePlacedNodeSelected}
@@ -283,6 +337,13 @@ export const ToolManager: React.FC = () => {
             tools above. Lives inside the building-local group so the
             building-local guide coords render at the right world position. */}
         <Alignment3DGuideLayer />
+        {/* The one forward-facing triangle renderer. Placement/move tools
+            publish their ghost pose to `useFacingPose`; this draws it. Mounted
+            here so it shares the building-local frame the tools publish in. */}
+        <FacingPoseIndicator />
+        {/* Wall-plane proximity / sill / equal-spacing guides for openings,
+            published by the door/window move tools in the same world frame. */}
+        <OpeningGuides3DLayer />
         {/* "Magnetic" beacon at the active wall-draft snap point. */}
         <WallSnapBeaconLayer />
       </group>