@pascal-app/editor 1.0.6 → 1.1.0

package/src/components/editor/use-floorplan-background-placement.ts

@@ -19,6 +19,8 @@ import { resolveGenericFloorplanGridEventPoint } from '../../lib/floorplan-grid-
 import { snapRegisteredDraftPoint } from '../../lib/registered-draft-snap'
 import { resolveSlabPlanPointSnap } from '../../lib/slab-plan-snap'
 import { commitWallPolygonDraft, wallPolygonDraftWalls } from '../../lib/wall-polygon-draft'
+import { wallDraftIsRun } from '../../lib/wall-pull'
+import { isWallRunFree, snapWallRunDraftPoint } from '../../lib/wall-run-snap'
 import useAlignmentGuides from '../../store/use-alignment-guides'
 import useEditor, { isAngleSnapActive, isMagneticSnapActive } from '../../store/use-editor'
 import usePlacementPreview from '../../store/use-placement-preview'
@@ -52,6 +54,8 @@ type UseFloorplanBackgroundPlacementArgs = {
     wall: WallNode
   } | null
   floorplanOpeningLocalY: number
+  /** An open wall run's start and the direction of its last wall (null before one). */
+  getWallRunContext: () => { runStart: WallPlanPoint | null; reference: WallPlanPoint | null }
   getSnappedFloorplanPoint: (point: WallPlanPoint) => WallPlanPoint
   handleCeilingItemPlacementClick: (
     planPoint: WallPlanPoint,
@@ -72,12 +76,9 @@ type UseFloorplanBackgroundPlacementArgs = {
   isZoneBuildActive: boolean
   levelId: string | null
   registryToolOwnsSnapping: boolean
-  roofDraftStart: WallPlanPoint | null
   setCursorPoint: React.Dispatch<React.SetStateAction<WallPlanPoint | null>>
   setFenceDraftEnd: React.Dispatch<React.SetStateAction<WallPlanPoint | null>>
   setFenceDraftStart: React.Dispatch<React.SetStateAction<WallPlanPoint | null>>
-  setRoofDraftEnd: React.Dispatch<React.SetStateAction<WallPlanPoint | null>>
-  setRoofDraftStart: React.Dispatch<React.SetStateAction<WallPlanPoint | null>>
   snapWallDraftPoint: (args: {
     point: WallPlanPoint
     walls: WallNode[]
@@ -86,6 +87,7 @@ type UseFloorplanBackgroundPlacementArgs = {
     bypassSnap?: boolean
     step?: number
     gridSnap?: (point: WallPlanPoint) => WallPlanPoint
+    captureWallBodies?: boolean
   }) => WallPlanPoint
   snapPolygonDraftPoint: (args: {
     point: WallPlanPoint
@@ -95,10 +97,9 @@ type UseFloorplanBackgroundPlacementArgs = {
   toPoint2D: (point: WallPlanPoint) => { x: number; y: number }
   walls: WallNode[]
   /**
-   * Snap a building-local plan point to the world XZ grid at `step`.
-   * Injected so the hook doesn't have to know the building's rotation
-   * or position — used by wall / fence branches that snap at variable
-   * step.
+   * Snap a building-local plan point onto the building's grid lattice at
+   * `step` (the lattice the plan draws, which turns with the building).
+   * Injected — used by wall / fence branches that snap at variable step.
    */
   worldGridSnap: (point: WallPlanPoint, step: number) => WallPlanPoint
 }
@@ -115,6 +116,7 @@ export function useFloorplanBackgroundPlacement({
   findClosestWallPoint,
   floorplanOpeningLocalY,
   getSnappedFloorplanPoint,
+  getWallRunContext,
   handleCeilingItemPlacementClick,
   handleCeilingPlacementPoint,
   handleSlabPlacementPoint,
@@ -131,12 +133,9 @@ export function useFloorplanBackgroundPlacement({
   isZoneBuildActive,
   levelId,
   registryToolOwnsSnapping,
-  roofDraftStart,
   setCursorPoint,
   setFenceDraftEnd,
   setFenceDraftStart,
-  setRoofDraftEnd,
-  setRoofDraftStart,
   snapWallDraftPoint,
   snapPolygonDraftPoint,
   toPoint2D,
@@ -219,24 +218,14 @@ export function useFloorplanBackgroundPlacement({
       if (isRoofBuildActive) {
         // Footprint placement (polygon context: grid / lines / off, no angle),
         // mode-driven to match the chip. Alt is force/free at commit time;
-        // alignment display/pull follows the active magnetic mode.
+        // alignment display/pull follows the active magnetic mode. The roof
+        // tool snaps the corner it commits and writes the draft rectangle from
+        // it, so the plan shows exactly the roof the click makes.
         const snappedPoint = alignFloorplanDraftPoint(getSnappedFloorplanPoint(planPoint), {
           applySnap: isMagneticSnapActive(),
         })
         emitFloorplanGridEvent('click', snappedPoint, event)
         setCursorPoint(snappedPoint)
-
-        if (roofFootprintSource !== 'draw') {
-          clearRoofPlacementDraft()
-          return true
-        }
-
-        if (roofDraftStart) {
-          clearRoofPlacementDraft()
-        } else {
-          setRoofDraftStart(snappedPoint)
-          setRoofDraftEnd(snappedPoint)
-        }
         return true
       }
 
@@ -254,8 +243,8 @@ export function useFloorplanBackgroundPlacement({
 
       if (isFenceBuildActive) {
         // Fence draft: mode-driven (matches the chip), same as the move
-        // preview. `grid` snaps to the world XZ grid (rotation-safe via the
-        // `gridSnap` callback), `angles` locks 15° rays from the start, `lines`
+        // preview. `grid` snaps to the building's grid lattice (the `gridSnap`
+        // callback), `angles` locks 15° rays from the start, `lines`
         // pulls onto walls / fences / alignment, `off` is free.
         const fenceStep = getSegmentGridStep()
         const fenceAngleSnap = fenceDraftStart !== null && isAngleSnapActive()
@@ -363,30 +352,48 @@ export function useFloorplanBackgroundPlacement({
       // / draftEnd state in the floor plan would never update, leaving
       // the dashed-line draft preview invisible.
       if (isWallBuildActive) {
-        // Wall draft: mode-driven (matches the chip + the move-preview branch).
-        // `grid` snaps to the world XZ grid (rotation-safe via `gridSnap`),
-        // `angles` locks 15° rays from the start, `lines` pulls the endpoint
-        // onto existing wall corners / edges + alignment, `off` is free.
-        const wallStep = getSegmentGridStep()
-        const wallAngleSnap = draftStart !== null && isAngleSnapActive()
-        const wallSnapped = snapWallDraftPoint({
-          point: planPoint,
-          walls: [...walls, ...wallPolygonDraftWalls()],
-          start: draftStart ?? undefined,
-          angleSnap: wallAngleSnap,
-          gridSnap: (p) => worldGridSnap(p, wallStep),
-        })
-        const wallGridBase = worldGridSnap(planPoint, wallStep)
-        const wallLocked = wallSnapped[0] !== wallGridBase[0] || wallSnapped[1] !== wallGridBase[1]
-        let snappedPoint = wallSnapped
-        if (wallLocked) {
-          useAlignmentGuides.getState().clear()
+        // Wall draft, matching the move-preview branch: mode-driven (matches
+        // the chip). `grid` snaps to the building's grid lattice (`gridSnap`),
+        // `angles` locks a Walls segment to 15° rays from its start, `lines`
+        // pulls the point onto existing wall corners / edges + alignment, `off`
+        // is free, and in every mode but `lines` an end aimed into a wall's body
+        // joins that wall. A run's segment (a Polygon side, a pulled run) lands
+        // where the move showed it (`snapWallRunDraftPoint`).
+        let snappedPoint: WallPlanPoint
+        if (draftStart && wallDraftIsRun()) {
+          const run = getWallRunContext()
+          snappedPoint = snapWallRunDraftPoint({
+            point: planPoint,
+            start: draftStart,
+            runStart: run.runStart ?? draftStart,
+            reference: run.reference,
+            walls: [...walls, ...wallPolygonDraftWalls()],
+            free: isWallRunFree(event),
+          }).point
         } else {
-          // Alignment lines are shown in every mode; the pull applies only when
-          // magnetic ('lines') and the segment isn't angle-locked.
-          snappedPoint = alignFloorplanDraftPoint(wallSnapped, {
-            applySnap: isMagneticSnapActive() && !wallAngleSnap,
+          const wallStep = getSegmentGridStep()
+          const wallAngleSnap = draftStart !== null && isAngleSnapActive()
+          const wallSnapped = snapWallDraftPoint({
+            point: planPoint,
+            walls: [...walls, ...wallPolygonDraftWalls()],
+            start: draftStart ?? undefined,
+            angleSnap: wallAngleSnap,
+            gridSnap: (p) => worldGridSnap(p, wallStep),
+            captureWallBodies: true,
           })
+          const wallGridBase = worldGridSnap(planPoint, wallStep)
+          const wallLocked =
+            wallSnapped[0] !== wallGridBase[0] || wallSnapped[1] !== wallGridBase[1]
+          snappedPoint = wallSnapped
+          if (wallLocked) {
+            useAlignmentGuides.getState().clear()
+          } else {
+            // Alignment lines are shown in every mode; the pull applies only when
+            // magnetic ('lines') and the segment isn't angle-locked.
+            snappedPoint = alignFloorplanDraftPoint(wallSnapped, {
+              applySnap: isMagneticSnapActive() && !wallAngleSnap,
+            })
+          }
         }
 
         emitFloorplanGridEvent('click', snappedPoint, event)
@@ -437,12 +444,12 @@ export function useFloorplanBackgroundPlacement({
       activePolygonDraftPoints,
       ceilingDraftPoints,
       clearFencePlacementDraft,
-      clearRoofPlacementDraft,
       clearWallPlacementDraft,
       emitFloorplanGridEvent,
       fenceDraftStart,
       fences,
       findClosestWallPoint,
+      getWallRunContext,
       floorplanOpeningLocalY,
       getSnappedFloorplanPoint,
       handleCeilingItemPlacementClick,
@@ -459,14 +466,10 @@ export function useFloorplanBackgroundPlacement({
       isWallBuildActive,
       isZoneBuildActive,
       levelId,
-      roofDraftStart,
       registryToolOwnsSnapping,
-      roofFootprintSource,
       setCursorPoint,
       setFenceDraftEnd,
       setFenceDraftStart,
-      setRoofDraftEnd,
-      setRoofDraftStart,
       snapWallDraftPoint,
       snapPolygonDraftPoint,
       toPoint2D,

package/src/components/editor/views/view-bar.tsx

@@ -1,5 +1,6 @@
 'use client'
 
+import { type MessageDescriptor, type PascalI18n, usePascalI18n } from '@pascal-app/core'
 import { type GroundMode, useViewer } from '@pascal-app/viewer'
 import { ArrowLeftRight, Check, Columns2, MoreHorizontal, Pin, PinOff, X } from 'lucide-react'
 import { type ReactNode, useEffect, useRef } from 'react'
@@ -7,7 +8,7 @@ import { useIsMobile } from '../../../hooks/use-mobile'
 import { type EditorViewDescriptor, isSceneView, isViewPinned } from '../../../lib/editor-views'
 import { cn } from '../../../lib/utils'
 import useEditor from '../../../store/use-editor'
-import type { ViewPaneIndex } from '../../../store/view-layout'
+import { VIEW_2D, VIEW_3D, type ViewPaneIndex } from '../../../store/view-layout'
 import { IconRefGlyph } from '../../ui/icon-ref'
 import {
   DropdownMenu,
@@ -30,7 +31,16 @@ const IDLE =
   'text-muted-foreground/70 hover:bg-black/5 dark:hover:bg-white/8 hover:text-muted-foreground'
 
 /** The views of one pane: its pinned views, the one it shows, and a menu with the rest. */
+/** Built-in views are named by the editor; host and plugin views bring their own label. */
+function viewLabel(view: EditorViewDescriptor, i18n: PascalI18n): string {
+  if (view.id === VIEW_3D) return i18n._({ id: 'editor.views.view3d', message: '3D' })
+  if (view.id === VIEW_2D) return i18n._({ id: 'editor.views.view2d', message: '2D' })
+  if (view.id === PLUGINS_VIEW_ID) return i18n._({ id: 'editor.views.plugins', message: 'Plugins' })
+  return view.label
+}
+
 export function ViewTabs({ pane, className }: { pane: ViewPaneIndex; className?: string }) {
+  const i18n = usePascalI18n()
   const layout = useActiveViewLayout()
   const views = useEditorViews()
   const pinnedViews = useEditor((s) => s.pinnedViews)
@@ -58,7 +68,11 @@ export function ViewTabs({ pane, className }: { pane: ViewPaneIndex; className?:
   return (
     <div className={cn(GROUP, 'min-w-0 shrink', className)}>
       <div
-        aria-label={`Pane ${pane + 1} views`}
+        aria-label={i18n._({
+          id: 'editor.views.viewBar.paneViews',
+          message: 'Pane {pane} views',
+          values: { pane: pane + 1 },
+        })}
         className="flex min-w-0 overflow-x-auto [scrollbar-width:none]"
         role="tablist"
         ref={tabList}
@@ -102,16 +116,20 @@ export function ViewTabs({ pane, className }: { pane: ViewPaneIndex; className?:
                 }
               }}
               tabIndex={view.id === current ? 0 : -1}
-              title={view.label}
+              title={viewLabel(view, i18n)}
               role="tab"
               type="button"
             >
               <IconRefGlyph icon={view.icon} size={14} />
-              <span className="max-w-36 truncate">{view.label}</span>
+              <span className="max-w-36 truncate">{viewLabel(view, i18n)}</span>
             </button>
             {view.onClose && (
               <button
-                aria-label={`Close ${view.label}`}
+                aria-label={i18n._({
+                  id: 'editor.views.viewBar.closeLabel',
+                  message: 'Close {label}',
+                  values: { label: viewLabel(view, i18n) },
+                })}
                 className="mr-1 flex size-6 shrink-0 items-center justify-center rounded-full text-muted-foreground hover:bg-accent hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring"
                 onClick={view.onClose}
                 type="button"
@@ -128,9 +146,27 @@ export function ViewTabs({ pane, className }: { pane: ViewPaneIndex; className?:
 }
 
 const GROUND_MODES = [
-  { mode: 'auto', label: 'Auto', title: 'Veil the ground over a level below grade' },
-  { mode: 'solid', label: 'Solid', title: 'Keep the ground solid' },
-] as const satisfies ReadonlyArray<{ mode: GroundMode; label: string; title: string }>
+  {
+    mode: 'auto',
+    label: /* i18n */ { id: 'editor.views.viewBar.auto', message: 'Auto' },
+    title: /* i18n */ {
+      id: 'editor.views.viewBar.veilTheGroundOverALevel',
+      message: 'Veil the ground over a level below grade',
+    },
+  },
+  {
+    mode: 'solid',
+    label: /* i18n */ { id: 'editor.views.viewBar.solid', message: 'Solid' },
+    title: /* i18n */ {
+      id: 'editor.views.viewBar.keepTheGroundSolid',
+      message: 'Keep the ground solid',
+    },
+  },
+] as const satisfies ReadonlyArray<{
+  mode: GroundMode
+  label: MessageDescriptor
+  title: MessageDescriptor
+}>
 
 /**
  * Over a level below grade the ground is veiled so its rooms show, and the bar says so: the
@@ -139,6 +175,7 @@ const GROUND_MODES = [
  * a level at grade or only partly below it.
  */
 export function GroundModeToggle() {
+  const i18n = usePascalI18n()
   const belowGrade = useViewer((s) => s.belowGrade)
   const gradeStanding = useViewer((s) => s.gradeStanding)
   const groundWindowVeiled = useViewer((s) => s.groundWindowVeiled)
@@ -147,15 +184,31 @@ export function GroundModeToggle() {
   const veiled =
     groundMode === 'auto' &&
     ((belowGrade && gradeStanding !== 'partly-below-grade') || groundWindowVeiled)
-  const ground = veiled ? 'veiled' : 'solid'
-  const label =
+  const standing =
     gradeStanding === 'partly-below-grade'
-      ? `Partly below grade · ground ${ground}`
+      ? 'partly'
       : gradeStanding === 'below-grade'
-        ? `Below grade · ground ${ground}`
-        : `Ground ${ground}`
+        ? 'below'
+        : 'other'
+  const label = veiled
+    ? i18n._({
+        id: 'editor.views.viewBar.groundVeiled',
+        message:
+          '{standing, select, partly {Partly below grade · ground veiled} below {Below grade · ground veiled} other {Ground veiled}}',
+        values: { standing },
+      })
+    : i18n._({
+        id: 'editor.views.viewBar.groundSolid',
+        message:
+          '{standing, select, partly {Partly below grade · ground solid} below {Below grade · ground solid} other {Ground solid}}',
+        values: { standing },
+      })
   return (
-    <div aria-label="Ground" className={GROUP} role="group">
+    <div
+      aria-label={i18n._({ id: 'editor.views.viewBar.ground', message: 'Ground' })}
+      className={GROUP}
+      role="group"
+    >
       <span className="flex items-center px-2.5 text-muted-foreground text-xs">{label}</span>
       {GROUND_MODES.map(({ mode, label, title }) => (
         <button
@@ -163,10 +216,10 @@ export function GroundModeToggle() {
           className={cn(SEGMENT, groundMode === mode ? ACTIVE : IDLE)}
           key={mode}
           onClick={() => useViewer.getState().setGroundMode(mode)}
-          title={title}
+          title={i18n._(title)}
           type="button"
         >
-          {label}
+          {i18n._(label)}
         </button>
       ))}
     </div>
@@ -175,15 +228,16 @@ export function GroundModeToggle() {
 
 /** Split toggle and, split, the swap — at the right end of the last pane's bar. */
 function SplitControls() {
+  const i18n = usePascalI18n()
   const split = useActiveViewLayout().split
   return (
     <div className={GROUP}>
       {split && (
         <button
-          aria-label="Swap panes"
+          aria-label={i18n._({ id: 'editor.views.viewBar.swapPanes', message: 'Swap panes' })}
           className={cn(SEGMENT, IDLE, 'px-2')}
           onClick={() => useEditor.getState().swapPanes()}
-          title="Swap panes"
+          title={i18n._({ id: 'editor.views.viewBar.swapPanes', message: 'Swap panes' })}
           type="button"
         >
           <ArrowLeftRight className="h-3 w-3" />
@@ -193,11 +247,15 @@ function SplitControls() {
         aria-pressed={split}
         className={cn(SEGMENT, split ? ACTIVE : IDLE)}
         onClick={() => useEditor.getState().toggleSplit()}
-        title={split ? 'Close split (\\)' : 'Split (\\)'}
+        title={
+          split
+            ? i18n._({ id: 'editor.views.viewBar.closeSplit', message: 'Close split (\\)' })
+            : i18n._({ id: 'editor.views.viewBar.split', message: 'Split (\\)' })
+        }
         type="button"
       >
         <Columns2 className="h-3 w-3" />
-        <span>Split</span>
+        <span>{i18n._({ id: 'editor.views.viewBar.split2', message: 'Split' })}</span>
       </button>
     </div>
   )
@@ -272,6 +330,7 @@ function MoreViewsMenu({
   current: string
   views: EditorViewDescriptor[]
 }) {
+  const i18n = usePascalI18n()
   const pinnedViews = useEditor((s) => s.pinnedViews)
   const setPaneView = useEditor((s) => s.setPaneView)
   const setViewPinned = useEditor((s) => s.setViewPinned)
@@ -282,7 +341,7 @@ function MoreViewsMenu({
     <DropdownMenu>
       <DropdownMenuTrigger asChild>
         <button
-          aria-label="More views"
+          aria-label={i18n._({ id: 'editor.views.viewBar.moreViews', message: 'More views' })}
           className={cn(SEGMENT, IDLE, 'shrink-0 px-2')}
           type="button"
         >
@@ -290,7 +349,9 @@ function MoreViewsMenu({
         </button>
       </DropdownMenuTrigger>
       <DropdownMenuContent align="start" className="w-64">
-        <DropdownMenuLabel className="text-muted-foreground text-xs">Views</DropdownMenuLabel>
+        <DropdownMenuLabel className="text-muted-foreground text-xs">
+          {i18n._({ id: 'editor.views.viewBar.views', message: 'Views' })}
+        </DropdownMenuLabel>
         {listed.map((view) => {
           const pinned = isViewPinned(view, pinnedViews)
           return (
@@ -300,11 +361,23 @@ function MoreViewsMenu({
               onSelect={() => setPaneView(pane, view.id)}
             >
               <IconRefGlyph icon={view.icon} size={16} />
-              <span className="min-w-0 flex-1 truncate">{view.label}</span>
+              <span className="min-w-0 flex-1 truncate">{viewLabel(view, i18n)}</span>
               {view.id === current && <Check className="h-3.5 w-3.5 text-muted-foreground" />}
               {!isSceneView(view.id) && !view.onClose && !view.alwaysPinned && (
                 <button
-                  aria-label={pinned ? `Unpin ${view.label}` : `Pin ${view.label}`}
+                  aria-label={
+                    pinned
+                      ? i18n._({
+                          id: 'editor.views.viewBar.unpinLabel',
+                          message: 'Unpin {label}',
+                          values: { label: viewLabel(view, i18n) },
+                        })
+                      : i18n._({
+                          id: 'editor.views.viewBar.pinLabel',
+                          message: 'Pin {label}',
+                          values: { label: viewLabel(view, i18n) },
+                        })
+                  }
                   aria-pressed={pinned}
                   className={cn(
                     'flex h-6 w-6 items-center justify-center rounded-md transition-colors hover:bg-black/6 dark:hover:bg-white/10',
@@ -316,7 +389,17 @@ function MoreViewsMenu({
                     setViewPinned(view.id, !pinned)
                   }}
                   onPointerDown={(event) => event.stopPropagation()}
-                  title={pinned ? 'Unpin from the view bar' : 'Pin to the view bar'}
+                  title={
+                    pinned
+                      ? i18n._({
+                          id: 'editor.views.viewBar.unpinFromTheViewBar',
+                          message: 'Unpin from the view bar',
+                        })
+                      : i18n._({
+                          id: 'editor.views.viewBar.pinToTheViewBar',
+                          message: 'Pin to the view bar',
+                        })
+                  }
                   type="button"
                 >
                   {pinned ? <PinOff className="h-3.5 w-3.5" /> : <Pin className="h-3.5 w-3.5" />}
@@ -333,7 +416,9 @@ function MoreViewsMenu({
               onSelect={() => setPaneView(pane, PLUGINS_VIEW_ID)}
             >
               <img alt="" className="h-4 w-4 object-contain" src="/icons/plugins.webp" />
-              <span>Browse plugins</span>
+              <span>
+                {i18n._({ id: 'editor.views.viewBar.browsePlugins', message: 'Browse plugins' })}
+              </span>
             </DropdownMenuItem>
           </>
         )}

package/src/components/editor/wall-measurement-label.tsx

@@ -4,6 +4,7 @@ import {
   type AnyNode,
   type AnyNodeId,
   calculateLevelMiters,
+  formatLinearMeasurement,
   getWallCurveLength,
   getWallEffectiveHeightForNodes,
   getWallMiterBoundaryPoints,
@@ -20,11 +21,10 @@ import {
   type WallNode,
 } from '@pascal-app/core'
 import { getSceneTheme, useViewer } from '@pascal-app/viewer'
-import { Html } from '@react-three/drei'
 import { createPortal, useFrame } from '@react-three/fiber'
 import { useMemo, useState } from 'react'
 import * as THREE from 'three'
-import { formatLinearMeasurement } from '../../lib/measurements'
+import { Html } from './localized-html'
 
 const GUIDE_Y_OFFSET = 0.08
 const LABEL_LIFT = 0.08
@@ -315,16 +315,25 @@ function buildMeasurementGuide(
   const measurementPoints = measurementLine ?? fallbackMiddlePoints
   if (!measurementPoints) return null
 
-  const height = getWallEffectiveHeightForNodes(wall, nodes)
+  const heightStart = getWallEffectiveHeightForNodes(wall, nodes, 0)
+  const heightEnd = getWallEffectiveHeightForNodes(wall, nodes, 1)
   const startLocal = worldPointToWallLocal(wall, measurementPoints.start)
   const endLocal = worldPointToWallLocal(wall, measurementPoints.end)
   const curvedMeasurementPath = isCurvedWall(wall)
     ? getCurvedWallMeasurementPath(wall, miterData, levelWalls)
     : null
+  const dx = wall.end[0] - wall.start[0]
+  const dz = wall.end[1] - wall.start[1]
+  const wallChordLength = Math.hypot(dx, dz)
+  const getChordT = (localX: number) =>
+    wallChordLength > 1e-6 ? Math.max(0, Math.min(1, localX / wallChordLength)) : 0
+
   const guidePath: Vec3[] = curvedMeasurementPath
     ? curvedMeasurementPath.map((point) => {
         const localPoint = worldPointToWallLocal(wall, point)
-        return [localPoint[0], height + GUIDE_Y_OFFSET, localPoint[2]]
+        const t = getChordT(localPoint[0])
+        const h = getWallEffectiveHeightForNodes(wall, nodes, t)
+        return [localPoint[0], h + GUIDE_Y_OFFSET, localPoint[2]]
       })
     : isCurvedWall(wall)
       ? sampleWallCenterline(wall, 24).map((point, index, points) => {
@@ -334,12 +343,14 @@ function buildMeasurementGuide(
               : index === points.length - 1
                 ? endLocal
                 : worldPointToWallLocal(wall, point)
+          const t = getChordT(localPoint[0])
+          const h = getWallEffectiveHeightForNodes(wall, nodes, t)
 
-          return [localPoint[0], height + GUIDE_Y_OFFSET, localPoint[2]]
+          return [localPoint[0], h + GUIDE_Y_OFFSET, localPoint[2]]
         })
       : [
-          [startLocal[0], height + GUIDE_Y_OFFSET, startLocal[2]],
-          [endLocal[0], height + GUIDE_Y_OFFSET, endLocal[2]],
+          [startLocal[0], heightStart + GUIDE_Y_OFFSET, startLocal[2]],
+          [endLocal[0], heightEnd + GUIDE_Y_OFFSET, endLocal[2]],
         ]
 
   if (guidePath.length < 2) return null
@@ -397,26 +408,30 @@ function buildMeasurementGuide(
     ],
   })
   const bottomHeightTick = getHorizontalHeightTick(0)
-  const topHeightTick = getHorizontalHeightTick(height)
+  const topHeightTick = getHorizontalHeightTick(heightEnd)
 
   return {
     guidePath,
-    extStartStart: [extensionStartBase[0], height, extensionStartBase[2]],
+    extStartStart: [extensionStartBase[0], heightStart, extensionStartBase[2]],
     extStartEnd: [
       extensionStartBase[0],
-      height + GUIDE_Y_OFFSET + extOvershoot,
+      heightStart + GUIDE_Y_OFFSET + extOvershoot,
       extensionStartBase[2],
     ],
-    extEndStart: [extensionEndBase[0], height, extensionEndBase[2]],
-    extEndEnd: [extensionEndBase[0], height + GUIDE_Y_OFFSET + extOvershoot, extensionEndBase[2]],
+    extEndStart: [extensionEndBase[0], heightEnd, extensionEndBase[2]],
+    extEndEnd: [
+      extensionEndBase[0],
+      heightEnd + GUIDE_Y_OFFSET + extOvershoot,
+      extensionEndBase[2],
+    ],
     labelPosition: [midpoint[0], midpoint[1] + LABEL_LIFT, midpoint[2]],
     heightStart: [heightGuidePosition[0], 0, heightGuidePosition[2]],
-    heightEnd: [heightGuidePosition[0], height, heightGuidePosition[2]],
+    heightEnd: [heightGuidePosition[0], heightEnd, heightGuidePosition[2]],
     heightBottomTickStart: bottomHeightTick.start,
     heightBottomTickEnd: bottomHeightTick.end,
     heightTopTickStart: topHeightTick.start,
     heightTopTickEnd: topHeightTick.end,
-    heightLabelPosition: [heightGuidePosition[0], height / 2, heightGuidePosition[2]],
+    heightLabelPosition: [heightGuidePosition[0], heightEnd / 2, heightGuidePosition[2]],
   }
 }
 
@@ -530,7 +545,8 @@ function WallMeasurementAnnotation({ wall }: { wall: WallNode }) {
     return total
   }, [guide, wall])
   const label = formatLinearMeasurement(length, unit, metricNotation)
-  const height = useMemo(() => getWallEffectiveHeightForNodes(wall, nodes), [nodes, wall])
+  // Height annotation uses t=1 (wall end) because the vertical guide is drawn at the endpoint
+  const height = useMemo(() => getWallEffectiveHeightForNodes(wall, nodes, 1), [nodes, wall])
   const heightLabel = `H ${formatLinearMeasurement(height, unit, metricNotation)}`
 
   if (!(guide && Number.isFinite(length) && length >= 0.01)) return null