@pascal-app/editor 0.8.0 → 0.9.2

package/src/store/use-editor.tsx

@@ -2,14 +2,23 @@
 
 import type { AssetInput } from '@pascal-app/core'
 import {
+  type AnyNode,
   type AnyNodeId,
   type BuildingNode,
+  type CabinetModuleNode,
+  type CabinetNode,
   type CeilingNode,
+  type ChimneyMaterialRole,
+  type ChimneyNode,
   type ColumnNode,
   type DoorNode,
+  type DormerNode,
+  type DormerSurfaceMaterialRole,
+  type ElevatorNode,
   type FenceNode,
   type ItemNode,
   type LevelNode,
+  nodeRegistry,
   type RoofNode,
   type RoofSegmentNode,
   type RoofSurfaceMaterialRole,
@@ -27,7 +36,13 @@ import {
 import { useViewer } from '@pascal-app/viewer'
 import { create } from 'zustand'
 import { persist } from 'zustand/middleware'
-import { getDefaultCatalogItem } from '../components/ui/item-catalog/catalog-items'
+import {
+  CONTINUATION_PROFILES,
+  type ContinuationContext,
+  type ContinuationMode,
+  continuationContextOf,
+  nextContinuation,
+} from '../lib/continuation'
 import {
   type ActivePaintMaterial,
   type PaintableMaterialTarget,
@@ -35,14 +50,90 @@ import {
   resolvePaintTargetFromSelection,
   type SingleSurfaceMaterialRole,
 } from '../lib/material-paint'
+import {
+  type CreatableMeasurementKind,
+  DEFAULT_CREATABLE_MEASUREMENT_KIND,
+  normalizeCreatableMeasurementKind,
+} from '../lib/measurement-kind'
+import {
+  cyclePaintScope as cyclePaintScopeValue,
+  type PaintHoverInfo,
+  type PaintScope,
+} from '../lib/paint-scope'
+import {
+  cycleSnappingModeIn,
+  defaultSnappingModeFor,
+  resolveSnapFlags,
+  type SnapContext,
+  type SnappingMode,
+  snapContextOf,
+  snappingModesFor,
+} from '../lib/snapping-mode'
+import useInteractionScope from './use-interaction-scope'
 
-const DEFAULT_ACTIVE_SIDEBAR_PANEL = 'ai'
+const DEFAULT_ACTIVE_SIDEBAR_PANEL = 'build'
 const DEFAULT_FLOORPLAN_PANE_RATIO = 0.5
 const MIN_FLOORPLAN_PANE_RATIO = 0.15
 const MAX_FLOORPLAN_PANE_RATIO = 0.85
 
+function resolveMovingNodeTarget(
+  node:
+    | ItemNode
+    | WindowNode
+    | DoorNode
+    | ElevatorNode
+    | CeilingNode
+    | ChimneyNode
+    | ColumnNode
+    | DormerNode
+    | SlabNode
+    | WallNode
+    | FenceNode
+    | RoofNode
+    | RoofSegmentNode
+    | SpawnNode
+    | StairNode
+    | StairSegmentNode
+    | BuildingNode
+    | CabinetNode
+    | CabinetModuleNode,
+) {
+  return node
+}
+
 export type ViewMode = '3d' | '2d' | 'split'
 export type SplitOrientation = 'horizontal' | 'vertical'
+export type WorkspaceMode = 'edit' | 'studio'
+
+// Snapshot capture is invoked from two surfaces with different policies.
+// `standard` mirrors the existing user-driven UX — pick region / viewport /
+// area, save the blob as a project thumbnail. `preset` is the constrained
+// variant for the unified preset capture flow (community save-as-preset
+// modal): the overlay locks to a square crop, the renderer clears alpha
+// (transparent background), and the rendered set is locked to `isolated`
+// — `ThumbnailGenerator` consults `captureMode.mode === 'preset'` and
+// applies those constraints. Keeping it a discriminated union lets us
+// add future modes without surfacing the choice to end users.
+// How the captured pixels are cropped: full-frame 16:9, raw canvas viewport,
+// or user-dragged area. Hosts (e.g. the studio capture bar) can preselect it
+// when entering capture mode.
+export type SnapshotCropMode = 'standard' | 'viewport' | 'area'
+/** Aspect presets available to `standard` crops. */
+export type SnapshotStandardAspect = '16:9' | '9:16' | '4:3' | '3:4' | '1:1'
+
+export type CaptureMode =
+  | { mode: 'idle' }
+  | { mode: 'standard'; crop?: SnapshotCropMode; standardAspect?: SnapshotStandardAspect }
+  | {
+      mode: 'preset'
+      isolated: AnyNodeId[]
+      framingBounds?: {
+        min: [number, number]
+        max: [number, number]
+        center: [number, number]
+        size: [number, number]
+      }
+    }
 
 export type Phase = 'site' | 'structure' | 'furnish'
 
@@ -58,15 +149,37 @@ export type StructureTool =
   | 'ceiling'
   | 'roof'
   | 'column'
+  | 'elevator'
   | 'stair'
   | 'item'
   | 'zone'
   | 'spawn'
   | 'window'
   | 'door'
+  | 'shelf'
+  | 'box-vent'
+  | 'ridge-vent'
+  | 'turbine-vent'
+  | 'cupola'
+  | 'eyebrow-vent'
+  | 'chimney'
+  | 'solar-panel'
+  | 'skylight'
+  | 'dormer'
+  | 'gutter'
+  | 'downspout'
+  | 'duct-segment'
+  | 'duct-fitting'
+  | 'duct-terminal'
+  | 'hvac-equipment'
+  | 'lineset'
+  | 'liquid-line'
+  | 'pipe-segment'
+  | 'pipe-fitting'
+  | 'pipe-trap'
 
 // Furnish mode tools (items and decoration)
-export type FurnishTool = 'item'
+export type FurnishTool = 'item' | 'cabinet'
 
 // Site mode tools
 export type SiteTool = 'property-line'
@@ -86,24 +199,43 @@ export type StructureLayer = 'zones' | 'elements'
 export type FloorplanSelectionTool = 'click' | 'marquee'
 export type GridSnapStep = 0.5 | 0.25 | 0.1 | 0.05
 
-// Combined tool type
-export type Tool = SiteTool | StructureTool | FurnishTool
+export type NavigationSyncSource = '2d' | '3d'
 
-export type MovingWallEndpoint = {
-  wall: WallNode
-  endpoint: 'start' | 'end'
+export type NavigationSyncPose = {
+  source: NavigationSyncSource
+  revision: number
+  target: [number, number, number]
+  azimuth: number
+  viewWidth: number
 }
 
-export type MovingFenceEndpoint = {
-  fence: FenceNode
-  endpoint: 'start' | 'end'
-}
+export type NavigationSyncPoseInput = Omit<NavigationSyncPose, 'revision'>
+
+// Combined tool type. Known literals keep autocomplete; the `(string & {})`
+// arm lets plugin-contributed tool ids (e.g. `'trees:tree'`) typecheck without
+// the host enumerating every plugin kind. The runtime dispatch is already
+// registry-first — `tool-manager` resolves `nodeRegistry.get(tool)?.tool` — so
+// an unknown-to-the-host tool string flows straight through to the plugin's
+// placement component.
+export type KnownTool = SiteTool | StructureTool | FurnishTool
+export type Tool = KnownTool | (string & {})
+
+/**
+ * Starting parameters seeded into a draw tool before it mints a node.
+ * A loose param bag — the tool's create path validates it through the
+ * kind's schema (`FenceNode.parse({ ...defaults, start, end })`), which
+ * is the real type gate, so unknown keys are simply ignored.
+ */
+export type ToolDefaults = Record<string, unknown>
 
 export type MaterialTargetRole =
   | WallSurfaceSide
   | StairSurfaceMaterialRole
   | RoofSurfaceMaterialRole
+  | ChimneyMaterialRole
+  | DormerSurfaceMaterialRole
   | SingleSurfaceMaterialRole
+  | string
 
 export type SelectedMaterialTarget = {
   nodeId: AnyNodeId
@@ -116,6 +248,8 @@ type MaterialPaintSelectionSnapshot = {
   activePaintMaterial: ActivePaintMaterial | null
 }
 
+export type SurfaceHoleTarget = { nodeId: string; holeIndex: number }
+
 export type GuideUiState = {
   locked?: boolean
   scaleReferenceVisible?: boolean
@@ -128,35 +262,42 @@ type EditorState = {
   setMode: (mode: Mode) => void
   tool: Tool | null
   setTool: (tool: Tool | null) => void
+  /**
+   * Per-tool starting parameters for the next node a draw tool mints.
+   * Transient (not persisted): host apps seed an entry just before
+   * activating the tool (placing a drawn preset, or a future dimension
+   * picker), the tool's create path merges it, and the tool clears its
+   * own entry on deactivation so a later manual draw isn't poisoned.
+   */
+  toolDefaults: Partial<Record<Tool, ToolDefaults>>
+  setToolDefaults: (tool: Tool, defaults: ToolDefaults | null) => void
+  lastMeasurementKind: CreatableMeasurementKind
+  setLastMeasurementKind: (kind: CreatableMeasurementKind) => void
   structureLayer: StructureLayer
   setStructureLayer: (layer: StructureLayer) => void
   catalogCategory: CatalogCategory | null
   setCatalogCategory: (category: CatalogCategory | null) => void
   selectedItem: AssetInput | null
   setSelectedItem: (item: AssetInput) => void
-  movingNode:
-    | ItemNode
-    | WindowNode
-    | DoorNode
-    | CeilingNode
-    | ColumnNode
-    | SlabNode
-    | WallNode
-    | FenceNode
-    | RoofNode
-    | RoofSegmentNode
-    | SpawnNode
-    | StairNode
-    | StairSegmentNode
-    | BuildingNode
-    | null
+  /**
+   * True while a move was engaged by a press-drag gizmo (the on-canvas move
+   * cross) rather than a click-to-place flow. The placement coordinator reads
+   * this to commit on pointer-release instead of waiting for a click.
+   */
+  placementDragMode: boolean
+  setPlacementDragMode: (dragMode: boolean) => void
+  roofHostDragArmedId: AnyNodeId | null
+  setRoofHostDragArmedId: (nodeId: AnyNodeId | null) => void
   setMovingNode: (
     node:
       | ItemNode
       | WindowNode
       | DoorNode
+      | ElevatorNode
       | CeilingNode
+      | ChimneyNode
       | ColumnNode
+      | DormerNode
       | SlabNode
       | WallNode
       | FenceNode
@@ -166,29 +307,80 @@ type EditorState = {
       | StairNode
       | StairSegmentNode
       | BuildingNode
+      | CabinetNode
+      | CabinetModuleNode
       | null,
   ) => void
-  movingWallEndpoint: MovingWallEndpoint | null
-  setMovingWallEndpoint: (value: MovingWallEndpoint | null) => void
-  movingFenceEndpoint: MovingFenceEndpoint | null
-  setMovingFenceEndpoint: (value: MovingFenceEndpoint | null) => void
-  curvingWall: WallNode | null
-  setCurvingWall: (wall: WallNode | null) => void
-  curvingFence: FenceNode | null
-  setCurvingFence: (fence: FenceNode | null) => void
+  /**
+   * Which view (2D floor plan or 3D viewer) most recently completed
+   * the active move — set by the committing or cancelling side just
+   * before clearing `movingNode`. Lets the *other* side's effect
+   * cleanup skip its own restore-from-snapshot when the drag was
+   * already finalised elsewhere (split view mounts both the 2D
+   * overlay and the 3D move tool for the same `movingNode`).
+   *
+   * Reset to null when the next non-null `setMovingNode` starts a
+   * fresh drag (so stale values from the previous drag don't poison
+   * cleanups). Preserved across `setMovingNode(null)` so the
+   * non-owning side's cleanup — which fires after the clear
+   * propagates — can still read who finalised. Null while a drag
+   * is in progress means "no side has claimed it yet" — both
+   * cleanups then restore to their pre-drag snapshot, which is the
+   * same baseline, so the result is idempotent.
+   */
+  movingNodeOrigin: '2d' | '3d' | null
+  setMovingNodeOrigin: (origin: '2d' | '3d' | null) => void
+  /**
+   * World axis the R/T keyboard rotation turns around, for kinds with
+   * full 3D orientation (duct fittings). Alt cycles it Y → X → Z; the
+   * kind's tool / keyboard actions read it, and the floating action
+   * menu surfaces it in a pill above the selected node.
+   */
+  rotationAxis: 'x' | 'y' | 'z'
+  cycleRotationAxis: () => 'x' | 'y' | 'z'
   selectedMaterialTarget: SelectedMaterialTarget | null
   setSelectedMaterialTarget: (target: SelectedMaterialTarget | null) => void
   activePaintMaterial: ActivePaintMaterial | null
   setActivePaintMaterial: (material: ActivePaintMaterial | null) => void
   activePaintTarget: PaintableMaterialTarget
   setActivePaintTarget: (target: PaintableMaterialTarget) => void
+  // Live vertex count of an in-progress polygon draft (slab / ceiling), so the
+  // contextual HUD can gate hints on it (e.g. "Finish" only once ≥ 3 points).
+  // 0 when not drafting. Not persisted.
+  draftVertexCount: number
+  setDraftVertexCount: (count: number) => void
+  // Painter application scope — how far one paint click spreads (this surface /
+  // whole item / all matching / room). One global mode, target-aware in the HUD
+  // (see `lib/paint-scope.ts`), defaulting to the narrowest `'single'`. Not
+  // persisted: a "paint everything" scope should reset each session.
+  paintScope: PaintScope
+  setPaintScope: (scope: PaintScope) => void
+  // Cycle the scope within the hovered node's available set and return the new
+  // value. Bound to Shift while in paint mode.
+  cyclePaintScope: () => PaintScope
+  // When true, clicking a surface in paint mode clears it back to its
+  // default material instead of applying `activePaintMaterial`.
+  paintEraser: boolean
+  setPaintEraser: (eraser: boolean) => void
   primeMaterialPaintFromSelection: () => MaterialPaintSelectionSnapshot
-  hoveredPaintTarget: PaintableMaterialTarget | null
-  setHoveredPaintTarget: (target: PaintableMaterialTarget | null) => void
-  isPaintPanelOpen: boolean
-  setPaintPanelOpen: (open: boolean) => void
+  // What the cursor is over in paint mode: the scopes it offers + labels for the
+  // HUD chip. `null` when not over a paintable surface (drives the "hover a
+  // surface" hint). Set by the selection-manager paint hover; not persisted.
+  paintHover: PaintHoverInfo | null
+  setPaintHover: (info: PaintHoverInfo | null) => void
+  // Embedder capability: true when a host (e.g. community) can locate a selected
+  // node in its catalog browser. Gates the node action menu's "Find" button; the
+  // editor itself emits `selection:find-node` and lets the host fulfil it. Not
+  // persisted — it's a per-mount capability the host registers.
+  canFindNode: boolean
+  setCanFindNode: (canFind: boolean) => void
   selectedReferenceId: string | null
   setSelectedReferenceId: (id: string | null) => void
+  // Guide id with an in-flight reference-scale measurement (line drawing or
+  // length dialog). Owned by the floorplan panel; mirrored here so the
+  // reference panel can flip its Set Scale button into a Cancel.
+  referenceScaleActiveGuideId: string | null
+  setReferenceScaleActiveGuideId: (id: string | null) => void
   guideUi: Record<string, GuideUiState>
   setGuideLocked: (guideId: string, locked: boolean) => void
   setGuideScaleReferenceVisible: (guideId: string, visible: boolean) => void
@@ -196,15 +388,21 @@ type EditorState = {
   // Space detection for cutaway mode
   spaces: Record<string, Space>
   setSpaces: (spaces: Record<string, Space>) => void
-  // Generic hole editing (works for slabs, ceilings, and any future polygon nodes)
-  editingHole: { nodeId: string; holeIndex: number } | null
-  setEditingHole: (hole: { nodeId: string; holeIndex: number } | null) => void
+  hoveredHole: SurfaceHoleTarget | null
+  setHoveredHole: (hole: SurfaceHoleTarget | null) => void
   // Preview mode (viewer-like experience inside the editor)
   isPreviewMode: boolean
   setPreviewMode: (preview: boolean) => void
-  // Capture mode (snapshot toolbar — hides panels for clean framing)
+  // Capture mode (snapshot toolbar — hides panels for clean framing).
+  // `captureMode` is the canonical discriminated-union state; the boolean
+  // `isCaptureMode` is kept synced as a derived convenience for the many
+  // existing read sites that just gate chrome visibility on "is capture
+  // active". New write sites should pass a `CaptureMode` shape; passing a
+  // boolean is accepted as a back-compat shim (`true` → `'standard'`,
+  // `false` → `'idle'`).
+  captureMode: CaptureMode
   isCaptureMode: boolean
-  setCaptureMode: (active: boolean) => void
+  setCaptureMode: (next: boolean | CaptureMode) => void
   // View mode (3D only, 2D only, or split 2D+3D)
   viewMode: ViewMode
   setViewMode: (mode: ViewMode) => void
@@ -216,10 +414,38 @@ type EditorState = {
   toggleFloorplanOpen: () => void
   isFloorplanHovered: boolean
   setFloorplanHovered: (hovered: boolean) => void
+  // Toggleable DWV riser-diagram (plumbing isometric) overlay.
+  isRiserOpen: boolean
+  setRiserOpen: (open: boolean) => void
+  toggleRiserOpen: () => void
+  navigationSyncPose: NavigationSyncPose | null
+  publishNavigationSyncPose: (pose: NavigationSyncPoseInput) => void
   floorplanSelectionTool: FloorplanSelectionTool
   setFloorplanSelectionTool: (tool: FloorplanSelectionTool) => void
   gridSnapStep: GridSnapStep
   setGridSnapStep: (step: GridSnapStep) => void
+  // Cycles the grid step through GRID_SNAP_STEPS (0.5 → 0.25 → 0.1 → 0.05 →
+  // 0.5) and returns the new value. Bound to the measurement-step shortcut.
+  cycleGridSnapStep: () => GridSnapStep
+  // Magnetic snapping while drafting — snaps wall endpoints onto existing
+  // wall corners / wall bodies (the "magnetic" beacon). Independent of grid
+  // snap. On by default; toggled from the Display menu.
+  magneticSnap: boolean
+  setMagneticSnap: (enabled: boolean) => void
+  // Per-context, user-cyclable snapping mode (see `lib/snapping-mode.ts`). Each
+  // activity (wall / item / polygon) keeps its own mode + default, because they
+  // want different snapping — drawing a wall wants grid + angle, nudging an item
+  // wants free movement that only catches alignment lines. Resolved to the live
+  // context via `getActiveSnappingMode()`; maps onto `gridSnapStep`/`magneticSnap`
+  // via `resolveSnapFlags`. Persisted per context.
+  snappingModeByContext: Record<SnapContext, SnappingMode>
+  setSnappingMode: (context: SnapContext, mode: SnappingMode) => void
+  // Cycle the *active* context's mode within its own set; returns the new value.
+  cycleSnappingMode: () => SnappingMode
+  continuationByContext: Record<ContinuationContext, ContinuationMode>
+  setContinuation: (context: ContinuationContext, mode: ContinuationMode) => void
+  cycleContinuation: (context: ContinuationContext) => ContinuationMode
+  getContinuation: (context: ContinuationContext) => ContinuationMode
   showReferenceFloor: boolean
   toggleReferenceFloor: () => void
   setShowReferenceFloor: (show: boolean) => void
@@ -230,13 +456,23 @@ type EditorState = {
   // Development-only camera debug flag for inspecting underside geometry
   allowUndergroundCamera: boolean
   setAllowUndergroundCamera: (enabled: boolean) => void
+  // Development-only debug overlay: draw each wall's opening-snap hit area
+  // (the capsule of points within the snap radius of its centerline). Lets us
+  // see why a door/window snaps where it does.
+  show2dVoronoi: boolean
+  setShow2dVoronoi: (enabled: boolean) => void
   // First-person walkthrough mode (street view)
   isFirstPersonMode: boolean
   _viewModeBeforeFirstPerson: ViewMode | null
   setFirstPersonMode: (enabled: boolean) => void
+  // Workspace mode: 'edit' is the full editing surface; 'studio' is the
+  // render/snapshot surface (clean canvas, no editing chrome or selection).
+  // Entering studio forces a 3D-only view and restores the prior view on exit.
+  workspaceMode: WorkspaceMode
+  _viewModeBeforeStudio: ViewMode | null
+  setWorkspaceMode: (mode: WorkspaceMode) => void
   activeSidebarPanel: string
   setActiveSidebarPanel: (id: string) => void
-  setIsCaptureMode: (enabled: boolean) => void
   floorplanPaneRatio: number
   setFloorplanPaneRatio: (ratio: number) => void
   // Mobile-only: pixel height of the secondary panel sheet while open (0 when closed).
@@ -257,6 +493,10 @@ type PersistedEditorLayoutState = Pick<
   | 'splitOrientation'
   | 'floorplanSelectionTool'
   | 'gridSnapStep'
+  | 'magneticSnap'
+  | 'lastMeasurementKind'
+  | 'snappingModeByContext'
+  | 'continuationByContext'
   | 'showReferenceFloor'
   | 'referenceFloorOffset'
   | 'referenceFloorOpacity'
@@ -279,6 +519,19 @@ export const DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE: PersistedEditorLayoutState =
   splitOrientation: 'horizontal',
   floorplanSelectionTool: 'click',
   gridSnapStep: 0.5,
+  magneticSnap: true,
+  lastMeasurementKind: DEFAULT_CREATABLE_MEASUREMENT_KIND,
+  snappingModeByContext: {
+    wall: defaultSnappingModeFor('wall'),
+    item: defaultSnappingModeFor('item'),
+    polygon: defaultSnappingModeFor('polygon'),
+  },
+  continuationByContext: {
+    wall: CONTINUATION_PROFILES.wall.default,
+    fence: CONTINUATION_PROFILES.fence.default,
+    point: CONTINUATION_PROFILES.point.default,
+    cabinet: CONTINUATION_PROFILES.cabinet.default,
+  },
   showReferenceFloor: false,
   referenceFloorOffset: 1,
   referenceFloorOpacity: 0.35,
@@ -286,6 +539,10 @@ export const DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE: PersistedEditorLayoutState =
 
 const GRID_SNAP_STEPS: GridSnapStep[] = [0.5, 0.25, 0.1, 0.05]
 
+type SelectDefaultBuildingAndLevelOptions = {
+  forceGroundLevel?: boolean
+}
+
 function normalizeModeForPhase(phase: Phase, mode: Mode | undefined): Mode {
   if (phase === 'site') {
     return 'select'
@@ -377,8 +634,51 @@ export function normalizePersistedEditorUiState(
   }
 }
 
+// Validate a persisted per-context mode against that context's allowed set
+// (so e.g. a stale `angles` for items resets), falling back to its default.
+function migrateSnappingMode(value: unknown, context: SnapContext): SnappingMode {
+  return snappingModesFor(context).includes(value as SnappingMode)
+    ? (value as SnappingMode)
+    : defaultSnappingModeFor(context)
+}
+
+type LegacyContinuationState = {
+  continuationByContext?: Partial<Record<ContinuationContext, unknown>>
+  wallChainMode?: unknown
+  fenceChainMode?: unknown
+}
+
+function migrateContinuationMode(
+  value: unknown,
+  context: ContinuationContext,
+): ContinuationMode | null {
+  const profile = CONTINUATION_PROFILES[context]
+  return profile.options.includes(value as ContinuationMode) ? (value as ContinuationMode) : null
+}
+
+function normalizeContinuationByContext(
+  state: LegacyContinuationState | null | undefined,
+): Record<ContinuationContext, ContinuationMode> {
+  return {
+    wall:
+      migrateContinuationMode(state?.continuationByContext?.wall, 'wall') ??
+      migrateContinuationMode(state?.wallChainMode, 'wall') ??
+      CONTINUATION_PROFILES.wall.default,
+    fence:
+      migrateContinuationMode(state?.continuationByContext?.fence, 'fence') ??
+      migrateContinuationMode(state?.fenceChainMode, 'fence') ??
+      CONTINUATION_PROFILES.fence.default,
+    point:
+      migrateContinuationMode(state?.continuationByContext?.point, 'point') ??
+      CONTINUATION_PROFILES.point.default,
+    cabinet:
+      migrateContinuationMode(state?.continuationByContext?.cabinet, 'cabinet') ??
+      CONTINUATION_PROFILES.cabinet.default,
+  }
+}
+
 function normalizePersistedEditorLayoutState(
-  state: Partial<PersistedEditorLayoutState> | null | undefined,
+  state: (Partial<PersistedEditorLayoutState> & LegacyContinuationState) | null | undefined,
 ): PersistedEditorLayoutState {
   return {
     activeSidebarPanel:
@@ -391,6 +691,15 @@ function normalizePersistedEditorLayoutState(
     gridSnapStep: GRID_SNAP_STEPS.includes(state?.gridSnapStep as GridSnapStep)
       ? (state?.gridSnapStep as GridSnapStep)
       : DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE.gridSnapStep,
+    // Default on: only an explicit persisted `false` disables it.
+    magneticSnap: state?.magneticSnap !== false,
+    lastMeasurementKind: normalizeCreatableMeasurementKind(state?.lastMeasurementKind),
+    snappingModeByContext: {
+      wall: migrateSnappingMode(state?.snappingModeByContext?.wall, 'wall'),
+      item: migrateSnappingMode(state?.snappingModeByContext?.item, 'item'),
+      polygon: migrateSnappingMode(state?.snappingModeByContext?.polygon, 'polygon'),
+    },
+    continuationByContext: normalizeContinuationByContext(state),
     showReferenceFloor: state?.showReferenceFloor === true,
     referenceFloorOffset:
       typeof state?.referenceFloorOffset === 'number' && state.referenceFloorOffset >= 1
@@ -420,46 +729,101 @@ export function hasCustomPersistedEditorUiState(
   )
 }
 
+function getDefaultLevelId(
+  buildingNode: BuildingNode,
+  nodes: Record<string, AnyNode>,
+): LevelNode['id'] | null {
+  const levels = buildingNode.children
+    .map((childId) => nodes[childId as AnyNodeId])
+    .filter((node): node is LevelNode => node?.type === 'level')
+
+  if (levels.length === 0) {
+    return null
+  }
+
+  const groundLevel = levels.find((level) => level.level === 0)
+  if (groundLevel) {
+    return groundLevel.id
+  }
+
+  const firstLevel = levels[0]
+  if (!firstLevel) {
+    return null
+  }
+
+  let lowestLevel = firstLevel
+  for (const level of levels.slice(1)) {
+    if (level.level < lowestLevel.level) {
+      lowestLevel = level
+    }
+  }
+
+  return lowestLevel.id
+}
+
 /**
  * Selects the first building and level 0 in the scene.
  * Safe to call any time — no-ops if already selected or scene is empty.
  */
-export function selectDefaultBuildingAndLevel() {
+export function selectDefaultBuildingAndLevel(options: SelectDefaultBuildingAndLevelOptions = {}) {
   const viewer = useViewer.getState()
   const scene = useScene.getState()
 
-  let buildingId = viewer.selection.buildingId
+  const selectedBuilding = viewer.selection.buildingId
+    ? scene.nodes[viewer.selection.buildingId]
+    : null
+  let buildingNode =
+    selectedBuilding?.type === 'building' ? (selectedBuilding as BuildingNode) : null
 
   // If no building selected, find the first one from site's children
-  if (!buildingId) {
+  if (!buildingNode) {
     const siteNode = scene.rootNodeIds[0] ? scene.nodes[scene.rootNodeIds[0]] : null
     if (siteNode?.type === 'site') {
-      const firstBuilding = siteNode.children
-        .map((child) => (typeof child === 'string' ? scene.nodes[child] : child))
-        .find((node) => node?.type === 'building')
-      if (firstBuilding) {
-        buildingId = firstBuilding.id as BuildingNode['id']
-        viewer.setSelection({ buildingId })
-      }
+      buildingNode =
+        siteNode.children
+          .map((childId) => scene.nodes[childId as AnyNodeId])
+          .find((node): node is BuildingNode => node?.type === 'building') ?? null
     }
   }
 
-  // If no level selected, find level 0 in the building
-  if (buildingId && !viewer.selection.levelId) {
-    const buildingNode = scene.nodes[buildingId] as BuildingNode
-    const level0Id = buildingNode.children.find((childId) => {
-      const levelNode = scene.nodes[childId] as LevelNode
-      return levelNode?.type === 'level' && levelNode.level === 0
-    })
-    if (level0Id) {
-      viewer.setSelection({ levelId: level0Id as LevelNode['id'] })
-    } else if (buildingNode.children[0]) {
-      // Fallback to first level if level 0 doesn't exist
-      viewer.setSelection({ levelId: buildingNode.children[0] as LevelNode['id'] })
-    }
+  if (!buildingNode) {
+    return
+  }
+
+  const selectedLevel = viewer.selection.levelId ? scene.nodes[viewer.selection.levelId] : null
+  const selectedLevelBelongsToBuilding =
+    selectedLevel?.type === 'level' && selectedLevel.parentId === buildingNode.id
+  const shouldSelectDefaultLevel = options.forceGroundLevel || !selectedLevelBelongsToBuilding
+  const defaultLevelId = shouldSelectDefaultLevel
+    ? getDefaultLevelId(buildingNode, scene.nodes as Record<string, AnyNode>)
+    : null
+
+  const selectionUpdate: Parameters<typeof viewer.setSelection>[0] = {}
+  if (viewer.selection.buildingId !== buildingNode.id) {
+    selectionUpdate.buildingId = buildingNode.id
   }
+  if (defaultLevelId) {
+    selectionUpdate.levelId = defaultLevelId
+  }
+
+  if (Object.keys(selectionUpdate).length > 0) {
+    viewer.setSelection(selectionUpdate)
+  }
+}
+
+export function selectSiteFloorplanContext() {
+  selectDefaultBuildingAndLevel({ forceGroundLevel: true })
+  useViewer.getState().setSelection({
+    selectedIds: [],
+    zoneId: null,
+  })
 }
 
+// Stashes the view mode the user was in before entering capture, so we can
+// restore it on exit. Snapshot capture always frames in 3D — the 2D/split
+// floorplan panes render nothing meaningful for a thumbnail.
+let viewModeBeforeCapture: ViewMode | null = null
+
 const useEditor = create<EditorState>()(
   persist(
     (set, get) => ({
@@ -488,12 +852,9 @@ const useEditor = create<EditorState>()(
           set({ mode: 'select', tool: null, catalogCategory: null })
         }
 
-        const viewer = useViewer.getState()
-
         switch (phase) {
           case 'site':
-            // In Site mode, we zoom out and deselect specific levels/buildings
-            viewer.resetSelection()
+            selectSiteFloorplanContext()
             break
 
           case 'structure':
@@ -531,9 +892,26 @@ const useEditor = create<EditorState>()(
         else if (tool) {
           set({ tool: null })
         }
+
+        const scope = useInteractionScope.getState()
+        if (mode === 'material-paint') scope.begin({ kind: 'painting' })
+        else scope.endIf((s) => s.kind === 'painting')
       },
       tool: DEFAULT_PERSISTED_EDITOR_UI_STATE.tool,
       setTool: (tool) => set({ tool }),
+      toolDefaults: {},
+      setToolDefaults: (tool, defaults) =>
+        set((state) => {
+          const next = { ...state.toolDefaults }
+          if (defaults === null) {
+            delete next[tool]
+          } else {
+            next[tool] = defaults
+          }
+          return { toolDefaults: next }
+        }),
+      lastMeasurementKind: DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE.lastMeasurementKind,
+      setLastMeasurementKind: (kind) => set({ lastMeasurementKind: kind }),
       structureLayer: DEFAULT_PERSISTED_EDITOR_UI_STATE.structureLayer,
       setStructureLayer: (layer) => {
         const { mode } = get()
@@ -555,38 +933,84 @@ const useEditor = create<EditorState>()(
       setCatalogCategory: (category) => set({ catalogCategory: category }),
       selectedItem: null,
       setSelectedItem: (item) => set({ selectedItem: item }),
-      movingNode: null as
-        | ItemNode
-        | WindowNode
-        | DoorNode
-        | CeilingNode
-        | SlabNode
-        | WallNode
-        | FenceNode
-        | RoofNode
-        | RoofSegmentNode
-        | StairNode
-        | StairSegmentNode
-        | BuildingNode
-        | null,
-      setMovingNode: (node) => set({ movingNode: node }),
-      movingWallEndpoint: null,
-      setMovingWallEndpoint: (value) => set({ movingWallEndpoint: value }),
-      movingFenceEndpoint: null,
-      setMovingFenceEndpoint: (value) => set({ movingFenceEndpoint: value }),
-      curvingWall: null,
-      setCurvingWall: (wall) => set({ curvingWall: wall }),
-      curvingFence: null,
-      setCurvingFence: (fence) => set({ curvingFence: fence }),
+      placementDragMode: false,
+      setPlacementDragMode: (dragMode) => set({ placementDragMode: dragMode }),
+      roofHostDragArmedId: null,
+      setRoofHostDragArmedId: (nodeId) => set({ roofHostDragArmedId: nodeId }),
+      // The node being placed/moved now lives inside the interaction scope
+      // (`useMovingNode` / `getMovingNode`), not a `useEditor` flag. This setter
+      // remains the single entry point: it drives the scope and still touches
+      // `movingNodeOrigin` / `placementDragMode` so cross-store subscribers that
+      // watch this store (community placement) keep firing on move start/end.
+      setMovingNode: (node) => {
+        const scope = useInteractionScope.getState()
+        if (node === null) {
+          scope.endIf((s) => s.kind === 'placing' || s.kind === 'moving')
+          // Preserve `movingNodeOrigin` across the clear so the non-owning
+          // side's effect cleanup — which fires after `setMovingNode(null)`
+          // propagates — can still read who finalised. The next non-null
+          // `setMovingNode` resets it. Always clear the press-drag flag.
+          set({ placementDragMode: false })
+          return
+        }
+        const targetNode = resolveMovingNodeTarget(node)
+        const isNew = Boolean((targetNode as { metadata?: { isNew?: boolean } }).metadata?.isNew)
+        if (isNew) {
+          scope.begin({
+            kind: 'placing',
+            node: targetNode,
+            nodeId: targetNode.id,
+            nodeType: targetNode.type,
+            view: '3d',
+            pressDrag: get().placementDragMode,
+          })
+        } else {
+          scope.begin({
+            kind: 'moving',
+            node: targetNode,
+            nodeId: targetNode.id,
+            nodeType: targetNode.type,
+            view: '3d',
+          })
+        }
+        set({ movingNodeOrigin: null })
+      },
+      movingNodeOrigin: null as '2d' | '3d' | null,
+      setMovingNodeOrigin: (origin) => set({ movingNodeOrigin: origin }),
+      rotationAxis: 'y',
+      cycleRotationAxis: () => {
+        const order = ['y', 'x', 'z'] as const
+        const next = order[(order.indexOf(get().rotationAxis as 'y' | 'x' | 'z') + 1) % 3]!
+        set({ rotationAxis: next })
+        return next
+      },
       selectedMaterialTarget: null,
       setSelectedMaterialTarget: (target) => set({ selectedMaterialTarget: target }),
       activePaintMaterial: null,
-      setActivePaintMaterial: (material) => set({ activePaintMaterial: material }),
+      // Picking a material implies paint, not erase — clear the eraser so the
+      // next click applies the chosen material.
+      setActivePaintMaterial: (material) =>
+        set({ activePaintMaterial: material, paintEraser: false }),
       activePaintTarget: 'wall',
       setActivePaintTarget: (target) =>
         set((state) =>
           state.activePaintTarget === target ? state : { activePaintTarget: target },
         ),
+      draftVertexCount: 0,
+      setDraftVertexCount: (count) =>
+        set((state) => (state.draftVertexCount === count ? state : { draftVertexCount: count })),
+      paintScope: 'single',
+      setPaintScope: (scope) => set({ paintScope: scope }),
+      cyclePaintScope: () => {
+        // Cycle within the hovered node's available scopes (what the click will
+        // actually hit). With nothing paintable hovered there's only `single`.
+        const scopes = get().paintHover?.scopes ?? (['single'] as PaintScope[])
+        const next = cyclePaintScopeValue(get().paintScope, scopes)
+        set({ paintScope: next })
+        return next
+      },
+      paintEraser: false,
+      setPaintEraser: (eraser) => set({ paintEraser: eraser }),
       primeMaterialPaintFromSelection: () => {
         const selectedId =
           useViewer.getState().selection.selectedIds.length === 1
@@ -614,15 +1038,14 @@ const useEditor = create<EditorState>()(
           activePaintMaterial: activePaintMaterial ?? get().activePaintMaterial,
         }
       },
-      hoveredPaintTarget: null,
-      setHoveredPaintTarget: (target) =>
-        set((state) =>
-          state.hoveredPaintTarget === target ? state : { hoveredPaintTarget: target },
-        ),
-      isPaintPanelOpen: false,
-      setPaintPanelOpen: (open) => set({ isPaintPanelOpen: open }),
+      paintHover: null,
+      setPaintHover: (info) => set({ paintHover: info }),
+      canFindNode: false,
+      setCanFindNode: (canFind) => set({ canFindNode: canFind }),
       selectedReferenceId: null,
       setSelectedReferenceId: (id) => set({ selectedReferenceId: id }),
+      referenceScaleActiveGuideId: null,
+      setReferenceScaleActiveGuideId: (id) => set({ referenceScaleActiveGuideId: id }),
       guideUi: {},
       setGuideLocked: (guideId, locked) =>
         set((state) => ({
@@ -655,8 +1078,14 @@ const useEditor = create<EditorState>()(
         }),
       spaces: {},
       setSpaces: (spaces) => set({ spaces }),
-      editingHole: null,
-      setEditingHole: (hole) => set({ editingHole: hole }),
+      hoveredHole: null,
+      setHoveredHole: (hole) =>
+        set((state) =>
+          state.hoveredHole?.nodeId === hole?.nodeId &&
+          state.hoveredHole?.holeIndex === hole?.holeIndex
+            ? state
+            : { hoveredHole: hole },
+        ),
       isPreviewMode: false,
       setPreviewMode: (preview) => {
         if (preview) {
@@ -667,8 +1096,41 @@ const useEditor = create<EditorState>()(
           set({ isPreviewMode: false })
         }
       },
+      captureMode: { mode: 'idle' } as CaptureMode,
       isCaptureMode: false,
-      setCaptureMode: (active) => set({ isCaptureMode: active }),
+      setCaptureMode: (next) => {
+        const resolved: CaptureMode =
+          typeof next === 'boolean' ? { mode: next ? 'standard' : 'idle' } : next
+        const entering = resolved.mode !== 'idle'
+        set((state) => {
+          if (entering) {
+            // Force 3D for the shot. Remember the prior mode only on the first
+            // entry (viewMode is already '3d' on re-entry), so we restore the
+            // user's real choice — not the forced '3d' — when capture ends.
+            if (state.viewMode !== '3d') {
+              viewModeBeforeCapture = state.viewMode
+              return {
+                captureMode: resolved,
+                isCaptureMode: true,
+                viewMode: '3d',
+                isFloorplanOpen: false,
+              }
+            }
+            return { captureMode: resolved, isCaptureMode: true }
+          }
+          const restore = viewModeBeforeCapture
+          viewModeBeforeCapture = null
+          if (restore && restore !== '3d') {
+            return {
+              captureMode: resolved,
+              isCaptureMode: false,
+              viewMode: restore,
+              isFloorplanOpen: true,
+            }
+          }
+          return { captureMode: resolved, isCaptureMode: false }
+        })
+      },
       viewMode: DEFAULT_PERSISTED_EDITOR_UI_STATE.viewMode,
       setViewMode: (mode) => set({ viewMode: mode, isFloorplanOpen: mode !== '3d' }),
       splitOrientation: DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE.splitOrientation,
@@ -682,10 +1144,63 @@ const useEditor = create<EditorState>()(
         }),
       isFloorplanHovered: false,
       setFloorplanHovered: (hovered) => set({ isFloorplanHovered: hovered }),
+      isRiserOpen: false,
+      setRiserOpen: (open) => set({ isRiserOpen: open }),
+      toggleRiserOpen: () => set((state) => ({ isRiserOpen: !state.isRiserOpen })),
+      navigationSyncPose: null,
+      publishNavigationSyncPose: (pose) =>
+        set((state) => ({
+          navigationSyncPose: {
+            ...pose,
+            revision: (state.navigationSyncPose?.revision ?? 0) + 1,
+          },
+        })),
       floorplanSelectionTool: 'click' as FloorplanSelectionTool,
       setFloorplanSelectionTool: (tool) => set({ floorplanSelectionTool: tool }),
       gridSnapStep: DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE.gridSnapStep,
       setGridSnapStep: (step) => set({ gridSnapStep: step }),
+      cycleGridSnapStep: () => {
+        const current = get().gridSnapStep
+        const index = GRID_SNAP_STEPS.indexOf(current)
+        const next = GRID_SNAP_STEPS[(index + 1) % GRID_SNAP_STEPS.length] ?? GRID_SNAP_STEPS[0]!
+        set({ gridSnapStep: next })
+        return next
+      },
+      magneticSnap: DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE.magneticSnap,
+      setMagneticSnap: (enabled) => set({ magneticSnap: enabled }),
+      snappingModeByContext: DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE.snappingModeByContext,
+      setSnappingMode: (context, mode) =>
+        set((state) => ({
+          snappingModeByContext: { ...state.snappingModeByContext, [context]: mode },
+        })),
+      cycleSnappingMode: () => {
+        const context = getActiveSnapContext() ?? 'item'
+        const current = get().snappingModeByContext[context]
+        const next = cycleSnappingModeIn(context, current)
+        set((state) => ({
+          snappingModeByContext: { ...state.snappingModeByContext, [context]: next },
+        }))
+        return next
+      },
+      continuationByContext: DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE.continuationByContext,
+      setContinuation: (context, mode) => {
+        const next =
+          migrateContinuationMode(mode, context) ?? CONTINUATION_PROFILES[context].default
+        set((state) => ({
+          continuationByContext: { ...state.continuationByContext, [context]: next },
+        }))
+      },
+      cycleContinuation: (context) => {
+        const next = nextContinuation(context, get().getContinuation(context))
+        set((state) => ({
+          continuationByContext: { ...state.continuationByContext, [context]: next },
+        }))
+        return next
+      },
+      getContinuation: (context) => {
+        const current = get().continuationByContext[context]
+        return migrateContinuationMode(current, context) ?? CONTINUATION_PROFILES[context].default
+      },
       showReferenceFloor: DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE.showReferenceFloor,
       toggleReferenceFloor: () =>
         set((state) => ({ showReferenceFloor: !state.showReferenceFloor })),
@@ -698,6 +1213,8 @@ const useEditor = create<EditorState>()(
         set({ referenceFloorOpacity: Math.min(0.8, Math.max(0.1, opacity)) }),
       allowUndergroundCamera: false,
       setAllowUndergroundCamera: (enabled) => set({ allowUndergroundCamera: enabled }),
+      show2dVoronoi: false,
+      setShow2dVoronoi: (enabled) => set({ show2dVoronoi: enabled }),
       isFirstPersonMode: false,
       _viewModeBeforeFirstPerson: null as ViewMode | null,
       setFirstPersonMode: (enabled) => {
@@ -721,9 +1238,34 @@ const useEditor = create<EditorState>()(
           })
         }
       },
+      workspaceMode: 'edit' as WorkspaceMode,
+      _viewModeBeforeStudio: null as ViewMode | null,
+      setWorkspaceMode: (mode) => {
+        if (get().workspaceMode === mode) return
+        if (mode === 'studio') {
+          const currentViewMode = get().viewMode
+          set({
+            workspaceMode: 'studio',
+            _viewModeBeforeStudio: currentViewMode,
+            viewMode: '3d',
+            isFloorplanOpen: false,
+            mode: 'select',
+            tool: null,
+            catalogCategory: null,
+          })
+          // Clear selection so no edit affordances bleed into the clean canvas.
+          useViewer.getState().setSelection({ selectedIds: [], zoneId: null })
+        } else {
+          const prevMode = get()._viewModeBeforeStudio
+          set({
+            workspaceMode: 'edit',
+            _viewModeBeforeStudio: null,
+            ...(prevMode ? { viewMode: prevMode, isFloorplanOpen: prevMode !== '3d' } : {}),
+          })
+        }
+      },
       activeSidebarPanel: DEFAULT_ACTIVE_SIDEBAR_PANEL,
       setActiveSidebarPanel: (id) => set({ activeSidebarPanel: id }),
-      setIsCaptureMode: (enabled) => set({ isCaptureMode: enabled }),
       floorplanPaneRatio: DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE.floorplanPaneRatio,
       setFloorplanPaneRatio: (ratio) =>
         set({ floorplanPaneRatio: normalizeFloorplanPaneRatio(ratio) }),
@@ -732,11 +1274,28 @@ const useEditor = create<EditorState>()(
     }),
     {
       name: 'pascal-editor-ui-preferences',
-      merge: (persistedState, currentState) => ({
-        ...currentState,
-        ...normalizePersistedEditorUiState(persistedState as Partial<PersistedEditorState>),
-        ...normalizePersistedEditorLayoutState(persistedState as Partial<PersistedEditorState>),
-      }),
+      merge: (persistedState, currentState) => {
+        const uiState = normalizePersistedEditorUiState(
+          persistedState as Partial<PersistedEditorState>,
+        )
+        const layoutState = normalizePersistedEditorLayoutState(
+          persistedState as Partial<PersistedEditorState>,
+        )
+
+        return {
+          ...currentState,
+          ...uiState,
+          ...layoutState,
+          ...(uiState.mode === 'build' && uiState.tool === 'measurement'
+            ? {
+                toolDefaults: {
+                  ...currentState.toolDefaults,
+                  measurement: { kind: layoutState.lastMeasurementKind },
+                },
+              }
+            : {}),
+        }
+      },
       partialize: (state) => ({
         phase: state.phase,
         mode: state.mode,
@@ -750,12 +1309,106 @@ const useEditor = create<EditorState>()(
         splitOrientation: state.splitOrientation,
         floorplanSelectionTool: state.floorplanSelectionTool,
         gridSnapStep: state.gridSnapStep,
+        magneticSnap: state.magneticSnap,
+        lastMeasurementKind: state.lastMeasurementKind,
+        snappingModeByContext: state.snappingModeByContext,
+        continuationByContext: state.continuationByContext,
         showReferenceFloor: state.showReferenceFloor,
         referenceFloorOffset: state.referenceFloorOffset,
         referenceFloorOpacity: state.referenceFloorOpacity,
       }),
+      skipHydration: true,
     },
   ),
 )
 
+/**
+ * Effective magnetic-snap state: the legacy `magneticSnap` flag AND the active
+ * context's snapping mode. With exclusive modes, magnetic (alignment axes + wall
+ * corner-join) is on only in `'lines'`. Read from the smallest magnetic choke
+ * points so the mode is honoured without retuning any snap math.
+ */
+export function isMagneticSnapActive(): boolean {
+  const state = useEditor.getState()
+  return state.magneticSnap && resolveSnapFlags(getActiveSnappingMode()).magnetic
+}
+
+/**
+ * Effective angle-lock state: the active context's snapping mode. With exclusive
+ * modes the 15°/45° lock is on only in `'angles'`. Read from the smallest
+ * angle-lock choke points (wall / fence draft call sites).
+ */
+export function isAngleSnapActive(): boolean {
+  return resolveSnapFlags(getActiveSnappingMode()).angles
+}
+
+/**
+ * Effective grid-lattice state: the active context's snapping mode. With
+ * exclusive modes the grid quantize is on only in `'grid'`.
+ */
+export function isGridSnapActive(): boolean {
+  return resolveSnapFlags(getActiveSnappingMode()).grid
+}
+
+/**
+ * Whether alignment "lines" should be DISPLAYED for the active context.
+ *
+ * True whenever a snappable context is active — in EVERY snapping mode,
+ * including `'off'`. The guides are passive reference feedback; this is
+ * decoupled from the magnetic *pull*: a producer publishes guides whenever this
+ * is true, but only applies the alignment delta when `isMagneticSnapActive()`
+ * (i.e. `'lines'`). So the user always sees the same alignment lines while
+ * snapping to grid / angles / off, and only snaps to them in `'lines'` mode.
+ */
+export function isAlignmentGuideActive(): boolean {
+  return getActiveSnapContext() !== null
+}
+
+/**
+ * The snapping context for what the user is currently doing (wall / item /
+ * polygon), or null when nothing snappable is active. Derived from the
+ * authoritative interaction scope, falling back to the armed build tool (the
+ * `drafting` scope isn't wired). The single source every snap reader + the HUD
+ * resolve their mode through.
+ */
+export function getActiveSnapContext(): SnapContext | null {
+  const editor = useEditor.getState()
+  return snapContextOf({
+    scope: useInteractionScope.getState().scope,
+    mode: editor.mode,
+    tool: editor.tool,
+    profileOf: (typeOrTool) => nodeRegistry.get(typeOrTool)?.snapProfile,
+    draftDirectionalOf: (typeOrTool) => nodeRegistry.get(typeOrTool)?.snapDraftDirectional ?? true,
+  })
+}
+
+export function getActiveContinuationContext(): ContinuationContext | null {
+  const scope = useInteractionScope.getState().scope
+  if (scope.kind === 'drafting') return continuationContextOf(scope.tool)
+  if (scope.kind === 'placing') return continuationContextOf(scope.nodeType)
+  if (scope.kind !== 'idle') return null
+
+  const editor = useEditor.getState()
+  if (editor.mode !== 'build' || !editor.tool) return null
+  return continuationContextOf(editor.tool)
+}
+
+export function getContinuation(context: ContinuationContext): ContinuationMode {
+  return useEditor.getState().getContinuation(context)
+}
+
+/**
+ * The effective snapping mode for the active context. Falls back to `'off'` when
+ * no snappable context is active (select / idle, no armed tool) so grid /
+ * magnetic / angle readers — including the snap-grid overlay — stay inert
+ * outside an interaction. Per-context defaults (item is `'grid'`) only take
+ * effect once a tool is armed or an interaction begins; otherwise the item
+ * default would light up the snap grid at idle.
+ */
+export function getActiveSnappingMode(): SnappingMode {
+  const context = getActiveSnapContext()
+  if (!context) return 'off'
+  return useEditor.getState().snappingModeByContext[context]
+}
+
 export default useEditor