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

package/src/store/use-editor.tsx

@@ -4,6 +4,7 @@ import type { AssetInput } from '@pascal-app/core'
 import {
   type AnyNode,
   type AnyNodeId,
+  type BrushSettings,
   type BuildingNode,
   type CabinetModuleNode,
   type CabinetNode,
@@ -11,6 +12,7 @@ import {
   type ChimneyMaterialRole,
   type ChimneyNode,
   type ColumnNode,
+  DEFAULT_BRUSH_SETTINGS,
   type DoorNode,
   type DormerNode,
   type DormerSurfaceMaterialRole,
@@ -28,6 +30,7 @@ import {
   type StairNode,
   type StairSegmentNode,
   type StairSurfaceMaterialRole,
+  type TerrainVerb,
   useScene,
   type WallNode,
   type WallSurfaceSide,
@@ -69,6 +72,7 @@ import {
   snapContextOf,
   snappingModesFor,
 } from '../lib/snapping-mode'
+import { publishNavigationSyncPoseToStore } from './navigation-sync-pose-store'
 import useInteractionScope from './use-interaction-scope'
 
 const DEFAULT_ACTIVE_SIDEBAR_PANEL = 'build'
@@ -137,10 +141,24 @@ export type CaptureMode =
 
 export type Phase = 'site' | 'structure' | 'furnish'
 
-export type Mode = 'select' | 'edit' | 'delete' | 'build' | 'material-paint'
+/**
+ * `terrain-sculpt` is a mode, not a build tool, and that is the whole answer to
+ * "how does terrain editing avoid conflicting with everything else".
+ *
+ * A build tool places a node and hands the pointer back. Sculpting is a
+ * sustained brush over the *ground* — the one surface every other tool uses as
+ * its reference plane — so while it is armed, clicks must not select a wall,
+ * drag a window, or arm a ghost. Modeling it as a mode gets that for free: it is
+ * mutually exclusive with `build`/`select`/`delete` by construction, every
+ * selection manager already early-returns unless `mode === 'select'`, and it
+ * holds a `sculpting` interaction scope for its whole lifetime so conflicting
+ * controls stay stepped back. `material-paint` is the existing precedent for
+ * exactly this shape.
+ */
+export type Mode = 'select' | 'edit' | 'delete' | 'build' | 'material-paint' | 'terrain-sculpt'
 
 // Structure mode tools (building elements)
-export type StructureTool =
+type BuiltInStructureTool =
   | 'wall'
   | 'fence'
   | 'room'
@@ -149,6 +167,7 @@ export type StructureTool =
   | 'ceiling'
   | 'roof'
   | 'column'
+  | 'structural-grid'
   | 'elevator'
   | 'stair'
   | 'item'
@@ -178,6 +197,9 @@ export type StructureTool =
   | 'pipe-fitting'
   | 'pipe-trap'
 
+/** Registry node kinds are valid build tools without central union edits. */
+export type StructureTool = BuiltInStructureTool | (string & {})
+
 // Furnish mode tools (items and decoration)
 export type FurnishTool = 'item' | 'cabinet'
 
@@ -363,6 +385,29 @@ type EditorState = {
   paintEraser: boolean
   setPaintEraser: (eraser: boolean) => void
   primeMaterialPaintFromSelection: () => MaterialPaintSelectionSnapshot
+  /**
+   * Terrain sculpt state. Lives here rather than in the tool component so the
+   * bottom-bar HUD, the keyboard shortcuts, and the brush all read one source —
+   * the same reason the paint mode's material/scope/eraser live here.
+   */
+  terrainVerb: TerrainVerb
+  setTerrainVerb: (verb: TerrainVerb) => void
+  terrainBrush: BrushSettings
+  setTerrainBrush: (settings: Partial<BrushSettings>) => void
+  /**
+   * Absolute height in metres the `flatten` verb aims at. Sampled by clicking
+   * the ground with the eyedropper, or typed. `null` means "sample on first
+   * click", which is what makes flatten usable without ever opening a number
+   * field.
+   */
+  terrainFlattenTarget: number | null
+  setTerrainFlattenTarget: (metres: number | null) => void
+  /**
+   * True while the next click should sample a flatten target instead of
+   * sculpting. One-shot: sampling clears it.
+   */
+  terrainSampling: boolean
+  setTerrainSampling: (sampling: 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.
@@ -544,8 +589,12 @@ type SelectDefaultBuildingAndLevelOptions = {
 }
 
 function normalizeModeForPhase(phase: Phase, mode: Mode | undefined): Mode {
+  // The site phase used to hard-return `select`, which made a site-phase brush
+  // mode unrepresentable. It is an allowlist now rather than a free-for-all:
+  // `delete` and `material-paint` still have nothing to act on at site scope, so
+  // letting them survive here would restore a mode with no targets.
   if (phase === 'site') {
-    return 'select'
+    return mode === 'terrain-sculpt' ? mode : 'select'
   }
 
   return mode === 'build' || mode === 'delete' || mode === 'material-paint' ? mode : 'select'
@@ -563,7 +612,7 @@ export function normalizePersistedEditorUiState(
   state: Partial<PersistedEditorUiState> | null | undefined,
 ): PersistedEditorUiState {
   const phase = state?.phase === 'structure' || state?.phase === 'furnish' ? state.phase : 'site'
-  const mode = normalizeModeForPhase(phase, state?.mode)
+  let mode = normalizeModeForPhase(phase, state?.mode)
 
   // Migrate old isFloorplanOpen to viewMode
   let viewMode: ViewMode = '3d'
@@ -574,6 +623,13 @@ export function normalizePersistedEditorUiState(
   }
   const isFloorplanOpen = viewMode !== '3d'
 
+  // Both are persisted independently, and rehydrate goes through neither setter,
+  // so this is the third place the sculpt/2D pair has to be reconciled. The view
+  // wins here for the same reason it does in `setViewMode`: a brush armed over a
+  // hidden canvas is a mode the user cannot use, and reviving one on load is
+  // worse than reviving it mid-session — nothing on screen explains it.
+  if (mode === 'terrain-sculpt' && viewMode === '2d') mode = 'select'
+
   if (phase === 'site') {
     return {
       ...DEFAULT_PERSISTED_EDITOR_UI_STATE,
@@ -824,6 +880,54 @@ export function selectSiteFloorplanContext() {
 // floorplan panes render nothing meaningful for a thumbnail.
 let viewModeBeforeCapture: ViewMode | null = null
 
+/**
+ * Hold the interaction scope that belongs to a sustained brush mode.
+ *
+ * Paint and sculpt are the two modes whose scope lifetime is the *mode*, not a
+ * pointer gesture. Both must be released whenever the mode changes for any
+ * reason — including the phase switch that resets the mode without going through
+ * `setMode`. A stuck `sculpting` scope would leave selection disabled across the
+ * whole editor, so this is one function called from every mode transition rather
+ * than a rule each transition remembers.
+ *
+ * The eyedropper arm rides along for the same reason: it is one-shot state whose
+ * UI is unmounted the moment sculpt mode ends, so it has to be cleared on every
+ * exit path and not just the one through `setMode`.
+ *
+ * Every `set({ mode: ... })` in this store must be followed by a call to this —
+ * see the callers in `setPhase`, `setStructureLayer`, `setPreviewMode`,
+ * `setFirstPersonMode` and `setWorkspaceMode`. The four view-swapping ones are
+ * the dangerous class: they unmount `ToolManager` (via `noEditing`), so the
+ * sculpt tool that would otherwise release the scope on unmount is gone, and a
+ * scope leaked there is unrecoverable without a reload.
+ */
+function syncBrushModeScope(mode: Mode): void {
+  const scope = useInteractionScope.getState()
+  if (mode === 'material-paint') scope.begin({ kind: 'painting' })
+  else if (mode === 'terrain-sculpt') scope.begin({ kind: 'sculpting' })
+  // `isBrushMode` is the same set as the two branches above — kept as one
+  // predicate so an added brush mode cannot be handled here and missed there.
+  else {
+    scope.endIf((s) => s.kind === 'painting' || s.kind === 'sculpting')
+    if (useEditor.getState().terrainSampling) useEditor.getState().setTerrainSampling(false)
+  }
+}
+
+/**
+ * Whether `mode` is one of the two sustained brush modes.
+ *
+ * Named because callers *outside* this store need the same test: a scope is
+ * single-owner, so anything that calls `begin()` while a brush mode holds its
+ * scope silently evicts it — the brush stays armed and painting while the rest of
+ * the editor believes a drag is running. Almost every producer is unreachable
+ * under a brush mode because it needs a selection and entering the mode clears
+ * one, but the clipboard paths read the clipboard instead (see
+ * `pasteSelectionAndPickUp`), so they have to ask.
+ */
+export function isBrushMode(mode: Mode): boolean {
+  return mode === 'material-paint' || mode === 'terrain-sculpt'
+}
+
 const useEditor = create<EditorState>()(
   persist(
     (set, get) => ({
@@ -852,6 +956,11 @@ const useEditor = create<EditorState>()(
           set({ mode: 'select', tool: null, catalogCategory: null })
         }
 
+        // Leaving the site phase must drop a held sculpt scope: this branch
+        // rewrites `mode` without going through `setMode`, so without this a
+        // stuck `sculpting` scope would disable selection in structure phase.
+        syncBrushModeScope(get().mode)
+
         switch (phase) {
           case 'site':
             selectSiteFloorplanContext()
@@ -870,6 +979,23 @@ const useEditor = create<EditorState>()(
       },
       mode: DEFAULT_PERSISTED_EDITOR_UI_STATE.mode,
       setMode: (mode) => {
+        // Sculpting is a site-phase mode. Arming it from structure/furnish moves
+        // the phase rather than failing silently: the user asked for the ground,
+        // and `normalizeModeForPhase` would otherwise reject the mode on the next
+        // rehydrate, leaving the UI showing a mode the store does not hold.
+        if (mode === 'terrain-sculpt' && get().phase !== 'site') {
+          get().setPhase('site')
+        }
+
+        // Same promotion, one axis over. The brush needs the 3D canvas: in `2d`
+        // the pane is only `display: none`, so the mode would arm, hold its
+        // scope and show its HUD while no pointer event could ever reach it.
+        // `split` is the smallest move that satisfies it — a plain `3d` would
+        // throw away a floorplan the user deliberately opened.
+        if (mode === 'terrain-sculpt' && get().viewMode === '2d') {
+          set({ viewMode: 'split', isFloorplanOpen: true })
+        }
+
         set({ mode })
 
         const { phase, structureLayer, tool } = get()
@@ -893,9 +1019,14 @@ const useEditor = create<EditorState>()(
           set({ tool: null })
         }
 
-        const scope = useInteractionScope.getState()
-        if (mode === 'material-paint') scope.begin({ kind: 'painting' })
-        else scope.endIf((s) => s.kind === 'painting')
+        if (mode === 'terrain-sculpt') {
+          // Sculpting acts on the ground, never on a node. Clearing the
+          // selection on entry is what stops the selected wall's gizmo from
+          // sitting under the brush, competing for the same clicks.
+          useViewer.getState().setSelection({ selectedIds: [], zoneId: null })
+        }
+
+        syncBrushModeScope(mode)
       },
       tool: DEFAULT_PERSISTED_EDITOR_UI_STATE.tool,
       setTool: (tool) => set({ tool }),
@@ -921,6 +1052,7 @@ const useEditor = create<EditorState>()(
           set({ structureLayer: layer, tool })
         } else {
           set({ structureLayer: layer, mode: 'select', tool: null })
+          syncBrushModeScope('select')
         }
 
         const viewer = useViewer.getState()
@@ -1040,6 +1172,21 @@ const useEditor = create<EditorState>()(
       },
       paintHover: null,
       setPaintHover: (info) => set({ paintHover: info }),
+      terrainVerb: 'flatten',
+      setTerrainVerb: (verb) =>
+        set({
+          terrainVerb: verb,
+          // Switching away from flatten drops the sampling arm — an eyedropper
+          // that survives into the raise brush would swallow its first click.
+          terrainSampling: verb === 'flatten' ? get().terrainSampling : false,
+        }),
+      terrainBrush: DEFAULT_BRUSH_SETTINGS,
+      setTerrainBrush: (settings) => set({ terrainBrush: { ...get().terrainBrush, ...settings } }),
+      terrainFlattenTarget: null,
+      setTerrainFlattenTarget: (metres) =>
+        set({ terrainFlattenTarget: metres, terrainSampling: false }),
+      terrainSampling: false,
+      setTerrainSampling: (sampling) => set({ terrainSampling: sampling }),
       canFindNode: false,
       setCanFindNode: (canFind) => set({ canFindNode: canFind }),
       selectedReferenceId: null,
@@ -1090,6 +1237,7 @@ const useEditor = create<EditorState>()(
       setPreviewMode: (preview) => {
         if (preview) {
           set({ isPreviewMode: true, mode: 'select', tool: null, catalogCategory: null })
+          syncBrushModeScope('select')
           // Clear zone/item selection for clean viewer drill-down hierarchy
           useViewer.getState().setSelection({ selectedIds: [], zoneId: null })
         } else {
@@ -1132,7 +1280,14 @@ const useEditor = create<EditorState>()(
         })
       },
       viewMode: DEFAULT_PERSISTED_EDITOR_UI_STATE.viewMode,
-      setViewMode: (mode) => set({ viewMode: mode, isFloorplanOpen: mode !== '3d' }),
+      setViewMode: (mode) => {
+        set({ viewMode: mode, isFloorplanOpen: mode !== '3d' })
+        // Going the other way, the view wins and the mode yields. Hiding the 3D
+        // pane leaves the brush unreachable, and a held `sculpting` scope would
+        // then keep selection suppressed in a floorplan the user is trying to
+        // work in — a mode you cannot use and cannot see how to leave.
+        if (mode === '2d' && get().mode === 'terrain-sculpt') get().setMode('select')
+      },
       splitOrientation: DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE.splitOrientation,
       setSplitOrientation: (orientation) => set({ splitOrientation: orientation }),
       isFloorplanOpen: DEFAULT_PERSISTED_EDITOR_UI_STATE.isFloorplanOpen,
@@ -1148,13 +1303,14 @@ const useEditor = create<EditorState>()(
       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,
-          },
-        })),
+      publishNavigationSyncPose: (pose) => {
+        const navigationSyncPose = {
+          ...pose,
+          revision: (get().navigationSyncPose?.revision ?? 0) + 1,
+        }
+        publishNavigationSyncPoseToStore(navigationSyncPose)
+        set({ navigationSyncPose })
+      },
       floorplanSelectionTool: 'click' as FloorplanSelectionTool,
       setFloorplanSelectionTool: (tool) => set({ floorplanSelectionTool: tool }),
       gridSnapStep: DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE.gridSnapStep,
@@ -1229,6 +1385,7 @@ const useEditor = create<EditorState>()(
             tool: null,
             catalogCategory: null,
           })
+          syncBrushModeScope('select')
         } else {
           const prevMode = get()._viewModeBeforeFirstPerson
           set({
@@ -1253,6 +1410,7 @@ const useEditor = create<EditorState>()(
             tool: null,
             catalogCategory: null,
           })
+          syncBrushModeScope('select')
           // Clear selection so no edit affordances bleed into the clean canvas.
           useViewer.getState().setSelection({ selectedIds: [], zoneId: null })
         } else {
@@ -1296,6 +1454,13 @@ const useEditor = create<EditorState>()(
             : {}),
         }
       },
+      // `mode` is persisted, but the interaction scope a brush mode holds is not
+      // — it lives in a separate, non-persisted store. Rehydrating into
+      // `terrain-sculpt` (or paint) without re-claiming the scope would restore
+      // the brush with selection still enabled, so every dab could grab a wall.
+      onRehydrateStorage: () => (state) => {
+        if (state) syncBrushModeScope(state.mode)
+      },
       partialize: (state) => ({
         phase: state.phase,
         mode: state.mode,
@@ -1378,6 +1543,10 @@ export function getActiveSnapContext(): SnapContext | null {
     mode: editor.mode,
     tool: editor.tool,
     profileOf: (typeOrTool) => nodeRegistry.get(typeOrTool)?.snapProfile,
+    profileOfNode: (nodeId) => {
+      const node = useScene.getState().nodes[nodeId as AnyNodeId]
+      return node ? nodeRegistry.get(node.type)?.snapProfile : undefined
+    },
     draftDirectionalOf: (typeOrTool) => nodeRegistry.get(typeOrTool)?.snapDraftDirectional ?? true,
   })
 }

package/src/store/use-elevation-guides.ts

@@ -0,0 +1,40 @@
+import { create } from 'zustand'
+
+export type ElevationGuide3D = {
+  ownerId: string
+  levelId: string
+  center: readonly [number, number]
+  direction: readonly [number, number]
+  elevation: number
+  label: string
+}
+
+type ElevationGuidesState = {
+  guide: ElevationGuide3D | null
+  publish(guide: ElevationGuide3D): void
+  clear(ownerId: string): void
+}
+
+const useElevationGuides = create<ElevationGuidesState>((set) => ({
+  guide: null,
+  publish: (guide) =>
+    set((state) => {
+      const current = state.guide
+      if (
+        current?.ownerId === guide.ownerId &&
+        current.levelId === guide.levelId &&
+        current.elevation === guide.elevation &&
+        current.label === guide.label &&
+        current.center[0] === guide.center[0] &&
+        current.center[1] === guide.center[1] &&
+        current.direction[0] === guide.direction[0] &&
+        current.direction[1] === guide.direction[1]
+      ) {
+        return state
+      }
+      return { guide }
+    }),
+  clear: (ownerId) => set((state) => (state.guide?.ownerId === ownerId ? { guide: null } : state)),
+}))
+
+export default useElevationGuides

package/src/store/use-fence-curve-draft.ts

@@ -1,21 +1,51 @@
-// Ephemeral store: how many points the in-progress curved-fence draft has
-// placed. Written by the 3D spline draft tool (`@pascal-app/nodes`
-// fence/tool.tsx) and read by the contextual helper so the "finish curve" hint
-// only surfaces once the user has actually started drawing. Reset on commit,
-// cancel, and unmount — never persisted, never in undo history.
+// Ephemeral store for the in-progress curved-fence draft. Written by the 3D
+// spline tool and read by the contextual helper plus out-of-tree consumers.
+// Reset on commit, cancel, and unmount — never persisted or recorded in undo
+// history.
 
 import { create } from 'zustand'
 
+export type FenceCurveDraftPoint = [number, number]
+
 type FenceCurveDraftState = {
   pointCount: number
-  setPointCount(count: number): void
+  points: FenceCurveDraftPoint[]
+  cursor: FenceCurveDraftPoint | null
+  setDraft(points: readonly FenceCurveDraftPoint[], cursor: FenceCurveDraftPoint | null): void
   reset(): void
 }
 
+function pointsEqual(a: readonly FenceCurveDraftPoint[], b: readonly FenceCurveDraftPoint[]) {
+  return (
+    a.length === b.length &&
+    a.every((point, index) => point[0] === b[index]?.[0] && point[1] === b[index]?.[1])
+  )
+}
+
 const useFenceCurveDraft = create<FenceCurveDraftState>((set) => ({
   pointCount: 0,
-  setPointCount: (count) => set({ pointCount: count }),
-  reset: () => set({ pointCount: 0 }),
+  points: [],
+  cursor: null,
+  setDraft: (points, cursor) =>
+    set((state) => {
+      const sameCursor =
+        (!cursor && !state.cursor) ||
+        Boolean(
+          cursor && state.cursor && state.cursor[0] === cursor[0] && state.cursor[1] === cursor[1],
+        )
+      if (sameCursor && pointsEqual(state.points, points)) return state
+      return {
+        pointCount: points.length,
+        points: points.map(([x, z]) => [x, z] as FenceCurveDraftPoint),
+        cursor: cursor ? [cursor[0], cursor[1]] : null,
+      }
+    }),
+  reset: () =>
+    set((state) =>
+      state.pointCount === 0 && state.points.length === 0 && state.cursor === null
+        ? state
+        : { pointCount: 0, points: [], cursor: null },
+    ),
 }))
 
 export default useFenceCurveDraft

package/src/store/use-first-person-hud.ts

@@ -0,0 +1,40 @@
+import { create } from 'zustand'
+
+export type WalkthroughInteract = { label: string; verb: string } | null
+
+export type FirstPersonHudState = {
+  floorLabel: string | null
+  zoneLabel: string | null
+  interact: WalkthroughInteract
+  setHud: (hud: Partial<Pick<FirstPersonHudState, 'floorLabel' | 'zoneLabel' | 'interact'>>) => void
+  reset: () => void
+}
+
+export const useFirstPersonHud = create<FirstPersonHudState>((set) => ({
+  floorLabel: null,
+  zoneLabel: null,
+  interact: null,
+  setHud: (hud) =>
+    set((state) => {
+      const floorLabel = hud.floorLabel === undefined ? state.floorLabel : hud.floorLabel
+      const zoneLabel = hud.zoneLabel === undefined ? state.zoneLabel : hud.zoneLabel
+      const interact = hud.interact === undefined ? state.interact : hud.interact
+
+      if (
+        floorLabel === state.floorLabel &&
+        zoneLabel === state.zoneLabel &&
+        interact?.label === state.interact?.label &&
+        interact?.verb === state.interact?.verb
+      ) {
+        return state
+      }
+
+      return { floorLabel, zoneLabel, interact }
+    }),
+  reset: () =>
+    set((state) =>
+      state.floorLabel === null && state.zoneLabel === null && state.interact === null
+        ? state
+        : { floorLabel: null, zoneLabel: null, interact: null },
+    ),
+}))

package/src/store/use-floorplan-annotation-visibility.ts

@@ -0,0 +1,60 @@
+'use client'
+
+import { create } from 'zustand'
+import { persist } from 'zustand/middleware'
+import {
+  DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+  type FloorplanAnnotationCategory,
+  type FloorplanAnnotationVisibility,
+  normalizeFloorplanAnnotationVisibility,
+} from '../lib/floorplan/annotation-visibility'
+import {
+  DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE,
+  type FloorplanWallDimensionReference,
+  normalizeFloorplanWallDimensionReference,
+} from '../lib/floorplan/floorplan-extension'
+
+type FloorplanAnnotationVisibilityState = {
+  visibility: FloorplanAnnotationVisibility
+  wallDimensionReference: FloorplanWallDimensionReference
+  setCategory: (category: FloorplanAnnotationCategory, visible: boolean) => void
+  setWallDimensionReference: (reference: FloorplanWallDimensionReference) => void
+  reset: () => void
+}
+
+const useFloorplanAnnotationVisibility = create<FloorplanAnnotationVisibilityState>()(
+  persist(
+    (set) => ({
+      visibility: { ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY },
+      wallDimensionReference: DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE,
+      setCategory: (category, visible) =>
+        set((state) => ({ visibility: { ...state.visibility, [category]: visible } })),
+      setWallDimensionReference: (wallDimensionReference) => set({ wallDimensionReference }),
+      reset: () =>
+        set({
+          visibility: { ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY },
+          wallDimensionReference: DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE,
+        }),
+    }),
+    {
+      name: 'pascal-floorplan-annotation-visibility',
+      merge: (persistedState, currentState) => ({
+        ...currentState,
+        visibility: normalizeFloorplanAnnotationVisibility(
+          (persistedState as { visibility?: unknown } | undefined)?.visibility,
+        ),
+        wallDimensionReference: normalizeFloorplanWallDimensionReference(
+          (persistedState as { wallDimensionReference?: unknown } | undefined)
+            ?.wallDimensionReference,
+        ),
+      }),
+      partialize: (state) =>
+        ({
+          visibility: state.visibility,
+          wallDimensionReference: state.wallDimensionReference,
+        }) as FloorplanAnnotationVisibilityState,
+    },
+  ),
+)
+
+export default useFloorplanAnnotationVisibility

package/src/store/use-floorplan-draft-preview.ts

@@ -17,6 +17,8 @@ import { create } from 'zustand'
 /** Screen-space (SVG-local px) cursor point — drives the coordinate badge. */
 type SvgPoint = { x: number; y: number }
 
+export type FloorplanPolygonDraftType = 'ceiling' | 'slab' | 'zone'
+
 type FloorplanDraftPreviewState = {
   /** Snapped plan-XZ point under the cursor; drives the crosshair + the
    *  cursor-following polygon-draft preview. `null` when idle. */
@@ -28,11 +30,18 @@ type FloorplanDraftPreviewState = {
   cursorPosition: SvgPoint | null
   /** Live END point of the open wall / fence / roof draft segment — the per-move
    *  endpoint that drives the 2D draft polygon + measurement. Each is `null`
-   *  unless that tool's draft is open. The START points stay in panel state
-   *  (set per click, low-frequency). */
+   *  unless that tool's draft is open. The START points are mirrored here (set
+   *  per click / per 3D draft move) so out-of-tree consumers — e.g. the hosted
+   *  host-owned preview publishers — can observe the whole open
+   *  segment; panel state remains the 2D interaction source of truth. */
   wallDraftEnd: WallPlanPoint | null
   fenceDraftEnd: WallPlanPoint | null
   roofDraftEnd: WallPlanPoint | null
+  wallDraftStart: WallPlanPoint | null
+  fenceDraftStart: WallPlanPoint | null
+  roofDraftStart: WallPlanPoint | null
+  polygonDraftType: FloorplanPolygonDraftType | null
+  polygonDraftPoints: WallPlanPoint[]
   /** Set the snapped cursor point. No-ops (skips the store update, so
    *  subscribers don't re-render) when unchanged — `grid:move` fires far more
    *  often than the snapped cell actually changes. */
@@ -42,11 +51,28 @@ type FloorplanDraftPreviewState = {
   setWallDraftEnd(point: WallPlanPoint | null): void
   setFenceDraftEnd(point: WallPlanPoint | null): void
   setRoofDraftEnd(point: WallPlanPoint | null): void
+  setWallDraftStart(point: WallPlanPoint | null): void
+  setFenceDraftStart(point: WallPlanPoint | null): void
+  setRoofDraftStart(point: WallPlanPoint | null): void
+  setPolygonDraft(type: FloorplanPolygonDraftType | null, points: readonly WallPlanPoint[]): void
   reset(): void
 }
 
+function planPointsEqual(a: readonly WallPlanPoint[], b: readonly WallPlanPoint[]) {
+  return (
+    a.length === b.length &&
+    a.every((point, index) => point[0] === b[index]?.[0] && point[1] === b[index]?.[1])
+  )
+}
+
 function setPlanPointField(
-  field: 'wallDraftEnd' | 'fenceDraftEnd' | 'roofDraftEnd',
+  field:
+    | 'fenceDraftEnd'
+    | 'fenceDraftStart'
+    | 'roofDraftEnd'
+    | 'roofDraftStart'
+    | 'wallDraftEnd'
+    | 'wallDraftStart',
   point: WallPlanPoint | null,
 ) {
   return (
@@ -65,6 +91,11 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
   wallDraftEnd: null,
   fenceDraftEnd: null,
   roofDraftEnd: null,
+  wallDraftStart: null,
+  fenceDraftStart: null,
+  roofDraftStart: null,
+  polygonDraftType: null,
+  polygonDraftPoints: [],
   setCursorPoint: (point) =>
     set((state) => {
       const prev = state.cursorPoint
@@ -82,13 +113,27 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
   setWallDraftEnd: (point) => set(setPlanPointField('wallDraftEnd', point)),
   setFenceDraftEnd: (point) => set(setPlanPointField('fenceDraftEnd', point)),
   setRoofDraftEnd: (point) => set(setPlanPointField('roofDraftEnd', point)),
+  setWallDraftStart: (point) => set(setPlanPointField('wallDraftStart', point)),
+  setFenceDraftStart: (point) => set(setPlanPointField('fenceDraftStart', point)),
+  setRoofDraftStart: (point) => set(setPlanPointField('roofDraftStart', point)),
+  setPolygonDraft: (type, points) =>
+    set((state) =>
+      state.polygonDraftType === type && planPointsEqual(state.polygonDraftPoints, points)
+        ? state
+        : { polygonDraftType: type, polygonDraftPoints: points.map(([x, z]) => [x, z]) },
+    ),
   reset: () =>
     set((state) =>
       state.cursorPoint === null &&
       state.cursorPosition === null &&
       state.wallDraftEnd === null &&
       state.fenceDraftEnd === null &&
-      state.roofDraftEnd === null
+      state.roofDraftEnd === null &&
+      state.wallDraftStart === null &&
+      state.fenceDraftStart === null &&
+      state.roofDraftStart === null &&
+      state.polygonDraftType === null &&
+      state.polygonDraftPoints.length === 0
         ? state
         : {
             cursorPoint: null,
@@ -96,6 +141,11 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
             wallDraftEnd: null,
             fenceDraftEnd: null,
             roofDraftEnd: null,
+            wallDraftStart: null,
+            fenceDraftStart: null,
+            roofDraftStart: null,
+            polygonDraftType: null,
+            polygonDraftPoints: [],
           },
     ),
 }))