feat(editor): node-declared per-context snapping + contextual HUD + painter scope

Generify the snapping/modifier HUD off the FSM scope and node declarations
instead of wall-creation-shaped, leaking pills.

- Per-context snapping (`snappingModeByContext`, persisted): wall / item /
  polygon mode-sets with exclusive modes (grid | lines | angles | off), each
  doing exactly what its chip says. Context is node-declared via the new
  `NodeDefinition.snapProfile` ('item' | 'structural'); the resolver maps
  (profile × action) → context with no per-kind switch.
- Scope-driven HUD: helper-manager reads the interaction scope; reshaping
  (endpoint/curve/boundary) and item move get their own chip, no select-hint
  leak. Rotate R/T rounds to 45°; Alt = force-place only (hidden for
  structural kinds); Shift = cycle everywhere.
- Slab/ceiling drafting: Shift=cycle, mode-aware grid/angle, Enter finishes
  (minDraftVertices); polygon boundary vertex/edge drag begins a reshaping
  scope. Fix grid/angle being ignored on boundary edit + slab creation:
  make resolveSurfacePlanPointSnap exclusive (alignment gated on magnetic) so
  grid/angles keep the snapped fallback instead of the raw cursor.
- Painter application scope: node-derived (single/object/matching/room) from
  the hovered node, cyclable via Shift, single-source HUD chip.
- Remove the redundant GridSnapControl from view-toggles (grid step lives in
  the contextual HUD now).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

packages/nodes/src/slab/tool.tsx

@@ -13,6 +13,8 @@ import {
   CursorSphere,
   clearSlabSnapFeedback,
   EDITOR_LAYER,
+  isAngleSnapActive,
+  isGridSnapActive,
   markToolCancelConsumed,
   resolveSlabPlanPointSnap,
   triggerSFX,
@@ -62,7 +64,6 @@ export const SlabTool: React.FC = () => {
   const [snappedCursorPosition, setSnappedCursorPosition] = useState<[number, number]>([0, 0])
   const [levelY, setLevelY] = useState(0)
   const previousSnappedPointRef = useRef<[number, number] | null>(null)
-  const shiftPressed = useRef(false)
 
   // Clear preset-seeded defaults on deactivation so a later manual slab draw
   // isn't built with a stale preset's parameters. Unmount-only.
@@ -70,42 +71,39 @@ export const SlabTool: React.FC = () => {
 
   useEffect(() => () => clearSlabSnapFeedback(), [])
 
+  // Publish the live vertex count so the HUD shows "Finish" only at ≥ 3 points.
+  useEffect(() => {
+    useEditor.getState().setDraftVertexCount(points.length)
+  }, [points.length])
+  useEffect(() => () => useEditor.getState().setDraftVertexCount(0), [])
+
   useEffect(() => {
     if (!currentLevelId) return
 
     const onGridMove = (event: GridEvent) => {
       if (!cursorRef.current) return
       const rawPoint: [number, number] = [event.localPosition[0], event.localPosition[2]]
-      const bypassSnap = shiftPressed.current || event.nativeEvent?.shiftKey === true
-      const gridPosition: [number, number] = bypassSnap
-        ? rawPoint
-        : [...snapPointToGrid(rawPoint, useEditor.getState().gridSnapStep)]
+      // Slab drafting is the 'polygon' snap context (grid / lines / off — no
+      // angle, no Shift bypass; Shift cycles the mode, Off is the bypass).
+      const gridStep = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0
+      const gridPosition: [number, number] = [...snapPointToGrid(rawPoint, gridStep)]
       setCursorPosition(gridPosition)
       setLevelY(event.localPosition[1])
       const lastPoint = points[points.length - 1]
-      // 15° angle snap from the raw cursor (matching the 2D floorplan
-      // pipeline) with the distance snapped along the ray to the grid step.
+      // Angle lock only when the mode asks for it (polygon never does today, but
+      // honour the flag so the behaviour follows the HUD).
       const orthoPoint: [number, number] =
-        bypassSnap || !lastPoint
-          ? gridPosition
-          : [
-              ...snapPointAlongAngleRay(
-                lastPoint,
-                rawPoint,
-                DEFAULT_ANGLE_STEP,
-                useEditor.getState().gridSnapStep,
-              ),
-            ]
+        isAngleSnapActive() && lastPoint
+          ? [...snapPointAlongAngleRay(lastPoint, rawPoint, DEFAULT_ANGLE_STEP, gridStep)]
+          : gridPosition
       const displayPoint = resolveSlabPlanPointSnap({
         rawPoint,
         fallbackPoint: orthoPoint,
         levelId: currentLevelId,
         altKey: event.nativeEvent?.altKey === true,
-        shiftKey: bypassSnap,
       }).point
       setSnappedCursorPosition(displayPoint)
       if (
-        !bypassSnap &&
         points.length > 0 &&
         previousSnappedPointRef.current &&
         (displayPoint[0] !== previousSnappedPointRef.current[0] ||
@@ -139,14 +137,18 @@ export const SlabTool: React.FC = () => {
       }
     }
 
+    // Finish the polygon (Enter or double-click): commit once there are enough
+    // vertices. Closing near the first vertex (in onGridClick) is the third way.
+    const finishDrawing = () => {
+      if (points.length < 3) return
+      const slabId = commitSlabDrawing(currentLevelId, points)
+      setSelection({ selectedIds: [slabId] })
+      setPoints([])
+      clearSlabSnapFeedback()
+    }
+
     const onGridDoubleClick = (_event: GridEvent) => {
-      if (!currentLevelId) return
-      if (points.length >= 3) {
-        const slabId = commitSlabDrawing(currentLevelId, points)
-        setSelection({ selectedIds: [slabId] })
-        setPoints([])
-        clearSlabSnapFeedback()
-      }
+      finishDrawing()
     }
 
     const onCancel = () => {
@@ -156,17 +158,12 @@ export const SlabTool: React.FC = () => {
     }
 
     const onKeyDown = (e: KeyboardEvent) => {
-      if (e.key === 'Shift') shiftPressed.current = true
-    }
-    const onKeyUp = (e: KeyboardEvent) => {
-      if (e.key === 'Shift') shiftPressed.current = false
-    }
-    const onWindowBlur = () => {
-      shiftPressed.current = false
+      if (e.key === 'Enter') {
+        e.preventDefault()
+        finishDrawing()
+      }
     }
     document.addEventListener('keydown', onKeyDown)
-    document.addEventListener('keyup', onKeyUp)
-    window.addEventListener('blur', onWindowBlur)
 
     emitter.on('grid:move', onGridMove)
     emitter.on('grid:click', onGridClick)
@@ -175,8 +172,6 @@ export const SlabTool: React.FC = () => {
 
     return () => {
       document.removeEventListener('keydown', onKeyDown)
-      document.removeEventListener('keyup', onKeyUp)
-      window.removeEventListener('blur', onWindowBlur)
       emitter.off('grid:move', onGridMove)
       emitter.off('grid:click', onGridClick)
       emitter.off('grid:double-click', onGridDoubleClick)