@pascal-app/editor 1.0.7 → 1.1.0

package/src/components/editor/floorplan-wall-typing-keys.test.tsx

@@ -0,0 +1,152 @@
+import { beforeEach, expect, test } from 'bun:test'
+import { emitter } from '@pascal-app/core'
+import { cancelActiveTool, useKeyboard } from '../../hooks/use-keyboard'
+import useEditor from '../../store/use-editor'
+import {
+  PLACEMENT_TYPING_LENGTH_ANGLE,
+  placementTypingLengthOptions,
+  usePlacementTyping,
+} from '../../store/use-placement-typing'
+import { sceneLayout } from '../../store/view-layout'
+import { withSelectionHarness } from '../../test-utils/selection-harness'
+import type { WallPlanPoint } from '../tools/wall/wall-drafting'
+import {
+  endFloorplanWallTypingOnCancel,
+  type FloorplanWallTypingDraft,
+  installFloorplanWallTypingKeys,
+} from './floorplan-wall-typing-keys'
+
+function GlobalShortcuts() {
+  useKeyboard()
+  return null
+}
+
+const press = (key: string) => {
+  const event = Object.assign(new Event('keydown', { cancelable: true }), {
+    key,
+    code: '',
+    metaKey: false,
+    ctrlKey: false,
+    altKey: false,
+    shiftKey: false,
+    repeat: false,
+  })
+  window.dispatchEvent(event)
+}
+
+beforeEach(() => {
+  usePlacementTyping.getState().clear()
+})
+
+test('2D-only typed wall keys run ahead of the global shortcuts', async () => {
+  await withSelectionHarness(async ({ render }) => {
+    useEditor.getState().setViewLayout(sceneLayout('2d'))
+    useEditor.getState().setPhase('building')
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+    // The global handler is registered first, as the app mounts it.
+    await render(<GlobalShortcuts />)
+
+    let draft: FloorplanWallTypingDraft | null = {
+      start: [0, 0],
+      pointer: [2, 0],
+      lengthOptions: placementTypingLengthOptions('metric', 'meters'),
+    }
+    const committed: WallPlanPoint[] = []
+    const dropDraft = () => {
+      draft = null
+    }
+    emitter.on('tool:cancel', dropDraft)
+    const uninstall = installFloorplanWallTypingKeys({
+      getDraft: () => draft,
+      commit: (pointer) => committed.push(pointer),
+    })
+    try {
+      press('1')
+      press('m')
+      expect(usePlacementTyping.getState().fields[0]).toBe('1m')
+      expect(useEditor.getState().phase).toBe('building')
+      expect(useEditor.getState().mode).toBe('build')
+      expect(useEditor.getState().tool).toBe('wall')
+
+      press('Escape')
+      expect(usePlacementTyping.getState().isActive).toBe(false)
+      expect(draft).not.toBeNull()
+      expect(useEditor.getState().tool).toBe('wall')
+
+      press('Escape')
+      expect(draft).toBeNull()
+      expect(committed).toEqual([])
+    } finally {
+      uninstall()
+      emitter.off('tool:cancel', dropDraft)
+      usePlacementTyping.getState().clear()
+    }
+  })
+})
+
+test('Enter commits the pointer the typed fields re-project, only in 2D-only view', async () => {
+  await withSelectionHarness(async () => {
+    const committed: WallPlanPoint[] = []
+    const uninstall = installFloorplanWallTypingKeys({
+      getDraft: () => ({
+        start: [0, 0],
+        pointer: [2, 0],
+        lengthOptions: placementTypingLengthOptions('metric', 'meters'),
+      }),
+      commit: (pointer) => committed.push(pointer),
+    })
+    try {
+      useEditor.getState().setViewLayout(sceneLayout('split'))
+      press('3')
+      expect(usePlacementTyping.getState().isActive).toBe(false)
+
+      useEditor.getState().setViewLayout(sceneLayout('2d'))
+      press('3')
+      press('Enter')
+      expect(committed).toEqual([[2, 0]])
+    } finally {
+      uninstall()
+      usePlacementTyping.getState().clear()
+    }
+  })
+})
+
+test('in 2D-only view a cancel from any source first ends the typed session, then the draft', async () => {
+  await withSelectionHarness(async () => {
+    useEditor.getState().setViewLayout(sceneLayout('2d'))
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+    let draftKept = true
+    // The plan's own `tool:cancel` handler.
+    const onCancel = () => {
+      if (endFloorplanWallTypingOnCancel()) return
+      draftKept = false
+    }
+    emitter.on('tool:cancel', onCancel)
+    try {
+      usePlacementTyping.getState().begin({ labels: PLACEMENT_TYPING_LENGTH_ANGLE })
+      usePlacementTyping.getState().append('3')
+
+      // The path ⌘Z takes mid-draft, not a keydown the plan sees itself.
+      expect(cancelActiveTool()).toBe(true)
+      expect(usePlacementTyping.getState().isActive).toBe(false)
+      expect(draftKept).toBe(true)
+      expect(useEditor.getState().mode).toBe('build')
+      expect(useEditor.getState().tool).toBe('wall')
+
+      cancelActiveTool()
+      expect(draftKept).toBe(false)
+    } finally {
+      emitter.off('tool:cancel', onCancel)
+    }
+  })
+})
+
+test('in split view the typed session and its cancel stay with the 3D wall tool', async () => {
+  await withSelectionHarness(async () => {
+    useEditor.getState().setViewLayout(sceneLayout('split'))
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+    usePlacementTyping.getState().begin({ labels: PLACEMENT_TYPING_LENGTH_ANGLE })
+    expect(endFloorplanWallTypingOnCancel()).toBe(true)
+    expect(usePlacementTyping.getState().isActive).toBe(true)
+  })
+})

package/src/components/editor/floorplan-wall-typing-keys.ts

@@ -0,0 +1,79 @@
+import { markToolCancelConsumed } from '../../hooks/use-keyboard'
+import type { ParseMeasurementOptions } from '../../lib/measurement-parser'
+import { isTypingTarget } from '../../lib/typing-target'
+import useEditor from '../../store/use-editor'
+import {
+  PLACEMENT_TYPING_LENGTH_ANGLE,
+  routePlacementTypingKey,
+  usePlacementTyping,
+} from '../../store/use-placement-typing'
+import { visibleScene } from '../../store/view-layout'
+import { getSegmentGridStep, type WallPlanPoint } from '../tools/wall/wall-drafting'
+import { resolveTypedWallEnd } from '../tools/wall/wall-typed-entry'
+
+export type FloorplanWallTypingDraft = {
+  start: WallPlanPoint
+  /** The plan-snapped pointer the typed fields re-project. */
+  pointer: WallPlanPoint
+  lengthOptions: ParseMeasurementOptions
+}
+
+/**
+ * Typed entry for the plan's own wall draft (2D-only view; in split view the
+ * 3D wall tool drafts and owns these keys). A window capture listener, so it
+ * runs before the global shortcuts and a typed `1`, `m` or the session's
+ * Escape never reaches them.
+ */
+export function installFloorplanWallTypingKeys({
+  getDraft,
+  commit,
+}: {
+  getDraft: () => FloorplanWallTypingDraft | null
+  commit: (pointer: WallPlanPoint) => void
+}): () => void {
+  const onKeyDown = (event: KeyboardEvent) => {
+    if (isTypingTarget(event.target)) return
+    if (visibleScene(useEditor.getState()) !== '2d') return
+    const draft = getDraft()
+    if (!draft) return
+    const outcome = routePlacementTypingKey(event, {
+      begin: (activeField) => {
+        usePlacementTyping.getState().begin({ labels: PLACEMENT_TYPING_LENGTH_ANGLE, activeField })
+        return true
+      },
+      tabBegins: true,
+    })
+    if (!outcome) return
+    event.preventDefault()
+    event.stopPropagation()
+    if (outcome !== 'commit') return
+    const typedEnd = resolveTypedWallEnd(
+      draft.start,
+      draft.pointer,
+      usePlacementTyping.getState().fields,
+      draft.lengthOptions,
+      getSegmentGridStep(),
+    )
+    if (typedEnd) commit(draft.pointer)
+  }
+  window.addEventListener('keydown', onKeyDown, true)
+  return () => window.removeEventListener('keydown', onKeyDown, true)
+}
+
+/**
+ * The plan's `tool:cancel` first stage. A cancel from any source (Escape, ⌘Z,
+ * a toolbar button) while a typed wall session is open only ends that
+ * session: in 2D-only view the plan clears it and consumes the cancel. In
+ * split view the 3D wall tool owns the session and its cancel. Returns true
+ * when the plan's wall draft must be kept.
+ */
+export function endFloorplanWallTypingOnCancel(): boolean {
+  const editor = useEditor.getState()
+  if (!(editor.mode === 'build' && editor.tool === 'wall')) return false
+  if (!usePlacementTyping.getState().isActive) return false
+  if (visibleScene(editor) === '2d') {
+    markToolCancelConsumed()
+    usePlacementTyping.getState().clear()
+  }
+  return true
+}

package/src/components/editor/footprint-height-handle.tsx

@@ -2,6 +2,7 @@
 
 import {
   type AnyNodeId,
+  formatLinearMeasurement,
   getStoredLevelHeight,
   type Point,
   type SlabNode,
@@ -20,7 +21,6 @@ import {
   THICK_FLOOR_HINT,
   thickFloorAdvice,
 } from '../../lib/floor-footprints'
-import { formatLinearMeasurement } from '../../lib/measurements'
 import { runRoomHandleDrag } from '../../lib/room-handle-drag'
 import useEditor, { isGridSnapActive } from '../../store/use-editor'
 import useInteractionScope from '../../store/use-interaction-scope'

package/src/components/editor/group-transform-shared.ts

@@ -3,6 +3,7 @@ import {
   type AnyNodeId,
   calculateLevelMiters,
   getWallPlanFootprint,
+  isMoveLocked,
   nodeRegistry,
   resolveBuildingForLevel,
   sceneRegistry,
@@ -99,7 +100,8 @@ export function classifyParticipant(
   levelId: string | null,
   sceneNodes: Record<string, AnyNode | undefined>,
 ): ParticipantKind | null {
-  if (!node || !isInGroupTransformScope(node, levelId, sceneNodes)) return null
+  if (!node || !isInGroupTransformScope(node, levelId, sceneNodes) || isMoveLocked(node))
+    return null
   const shape = classifyPlacementShape(node)
   if (shape) return shape
   const start = (node as { start?: unknown }).start

package/src/components/editor/index.tsx

@@ -4,6 +4,7 @@ import { Icon } from '@iconify/react'
 import {
   acquireSceneReadOnlyLease,
   createI18n,
+  emitter,
   getCatalogMaterialById,
   getLibraryMaterialIdFromRef,
   getMaterialSwatch,
@@ -43,6 +44,7 @@ import {
 } from 'react'
 import { ViewerOverlay } from '../../components/viewer-overlay'
 import { ViewerZoneSystem } from '../../components/viewer-zone-system'
+import { useAutoFrame } from '../../hooks/use-auto-frame'
 import { type SaveStatus, useAutoSave } from '../../hooks/use-auto-save'
 import { useKeyboard } from '../../hooks/use-keyboard'
 import { useIsMobile } from '../../hooks/use-mobile'
@@ -67,6 +69,7 @@ import {
   type SceneGraph,
   writePersistedSelection,
 } from '../../lib/scene'
+import { computeSceneBoundsXZ } from '../../lib/scene-bounds'
 import { disposeSFXBus, initSFXBus } from '../../lib/sfx-bus'
 import { useUnitFocusRules } from '../../lib/units'
 import { cn } from '../../lib/utils'
@@ -1570,6 +1573,8 @@ function EditorContent({
   useKeyboard({ isVersionPreviewMode, disabled: isFirstPersonMode || isStudioMode })
   useGestureLifecycleOwner()
 
+  useAutoFrame()
+
   const { beginSceneLoad, completeSceneLoad, saveNow } = useAutoSave({
     guardAgainstSceneWipe,
     onSave,
@@ -1741,6 +1746,21 @@ function EditorContent({
     return () => window.clearTimeout(timer)
   }, [hasLoadedInitialScene, isLoading, isSceneLoading, isViewerSceneReady, sceneReadyKey])
 
+  // The useAutoFrame emit can be clobbered by the level-follow effect's
+  // first-run pivot rest on fast (client-side navigation) loads. Re-emitting
+  // here is the last word after every load-driven camera effect has run.
+  // Once per load: a remounted viewer reports ready again, but only a new
+  // load reframes; remounted controls rest their own pivot on the level.
+  const framedSceneReadyKeyRef = useRef<number | null>(null)
+  useEffect(() => {
+    if (!isViewerSceneReady || framedSceneReadyKeyRef.current === sceneReadyKey) return
+    framedSceneReadyKeyRef.current = sceneReadyKey
+    const nodes = useScene.getState().nodes
+    if (Object.keys(nodes).length === 0) return
+    const bounds = computeSceneBoundsXZ(nodes)
+    emitter.emit('camera-controls:fit-scene', bounds ? { bounds } : {})
+  }, [isViewerSceneReady, sceneReadyKey])
+
   const isSceneDataLoading = isLoading || isSceneLoading || !hasLoadedInitialScene
   const showLoader = isSceneDataLoading || !isViewerSceneReady
   const visibleLoader =

package/src/components/editor/measurement-pill.tsx

@@ -1,8 +1,8 @@
 'use client'
 
+import { formatLinearMeasurement, type MetricNotation } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { type ForwardedRef, Fragment, forwardRef } from 'react'
-import { formatLinearMeasurement, type MetricNotation } from '../../lib/measurements'
 
 // Canonical in-world dimension formatter — metric metres or imperial
 // feet/inches. Shared by every measurement readout so they read the same.

package/src/components/editor/node-arrow-handles.tsx

@@ -9,6 +9,7 @@ import {
   createAngleAccumulator,
   createSceneApi,
   DEFAULT_ANGLE_STEP,
+  formatAngleRadians,
   type HandleDescriptor,
   type HandlePortal,
   type LatchHandle,
@@ -59,7 +60,6 @@ import useInteractionScope, {
   useMovingNode,
 } from '../../store/use-interaction-scope'
 import useOpeningGuides from '../../store/use-opening-guides'
-import { formatAngleRadians } from '../tools/shared/segment-angle'
 import {
   ARROW_COLOR,
   ARROW_HOVER_COLOR,

package/src/components/editor/open-wall-ends-3d-layer.tsx

@@ -1,7 +1,7 @@
 'use client'
 
 import { type OpenWallEnd, sceneRegistry } from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
+import { MEASUREMENT_DANGLING_COLOR, useViewer } from '@pascal-app/viewer'
 import { useFrame } from '@react-three/fiber'
 import { memo, useEffect, useMemo, useRef } from 'react'
 import { BoxGeometry, CircleGeometry, type Group, RingGeometry } from 'three'
@@ -13,7 +13,6 @@ import {
 } from '../../hooks/use-open-wall-ends'
 import { EDITOR_LAYER } from '../../lib/constants'
 import { openWallEndKey, openWallEndLabel } from '../../lib/floorplan/open-wall-ends'
-import { MEASUREMENT_DANGLING_COLOR } from '../../lib/measurements'
 import { cn } from '../../lib/utils'
 import useEditor from '../../store/use-editor'
 import { isViewVisible, VIEW_3D, visibleScene } from '../../store/view-layout'

package/src/components/editor/open-wall-ends-hint.tsx

@@ -1,10 +1,10 @@
 'use client'
 
 import { type AnyNodeId, emitter, type OpenWallEnd } from '@pascal-app/core'
+import { MEASUREMENT_DANGLING_COLOR } from '@pascal-app/viewer'
 import { useEffect, useState } from 'react'
 import { createPortal } from 'react-dom'
 import { openWallEndsSummary } from '../../lib/floorplan/open-wall-ends'
-import { MEASUREMENT_DANGLING_COLOR } from '../../lib/measurements'
 
 // The viewer area holds the floor plan and the 3D view side by side, so its
 // top centre clears both views' corner controls in 2D, 3D and split alike.

package/src/components/editor/quick-measurement-card.tsx

@@ -1,9 +1,9 @@
 'use client'
 
 import type { QuickMeasurementMetric, QuickMeasurementReport } from '@pascal-app/core'
+import { formatAreaLabel, formatLinearMeasurement, formatVolumeLabel } from '@pascal-app/core'
 import { Crosshair, MapPin } from 'lucide-react'
 import { memo } from 'react'
-import { formatAreaLabel, formatLinearMeasurement, formatVolumeLabel } from '../../lib/measurements'
 
 function formatMetric(
   metric: QuickMeasurementMetric,

package/src/components/editor/room-controls.tsx

@@ -6,7 +6,9 @@ import {
   DEFAULT_LEVEL_HEIGHT,
   deleteZone,
   emitter,
+  formatLinearMeasurement,
   type Point,
+  roomFloorElevation,
   type StructureNodes,
   sceneRegistry,
   useScene,
@@ -35,7 +37,6 @@ import { getRoomSelectionIndex } from '../../hooks/use-selected-room'
 import { EDITOR_LAYER } from '../../lib/constants'
 import { getFloatingMenuScale } from '../../lib/floating-menu-scale'
 import { clientToPlan } from '../../lib/floorplan/plan-coords'
-import { formatLinearMeasurement } from '../../lib/measurements'
 import { addMezzanineStairs } from '../../lib/mezzanine-stairs'
 import {
   cancelRoomDivide,
@@ -46,7 +47,7 @@ import {
   roomDivideContains,
   startRoomDivide,
 } from '../../lib/room-divide-session'
-import { roomFloorElevation, useRoomHandleDrag } from '../../lib/room-handle-drag'
+import { useRoomHandleDrag } from '../../lib/room-handle-drag'
 import type { RoomSelectionRecord } from '../../lib/room-selection'
 import { requestRoomDeletion } from '../../lib/room-structure-commands'
 import {

package/src/components/editor/room-handles-2d.tsx

@@ -4,6 +4,7 @@ import {
   type AnyNode,
   type AnyNodeId,
   type FloorplanGeometry,
+  formatLinearMeasurement,
   nodeRegistry,
   type Point,
   roomDrawnFloor,
@@ -15,7 +16,7 @@ import { type PointerEvent as ReactPointerEvent, useMemo, useState } from 'react
 import { useShallow } from 'zustand/react/shallow'
 import { useRoomRecords, useSelectedRoom } from '../../hooks/use-selected-room'
 import { getFloorplanNodeExtension } from '../../lib/floorplan/floorplan-extension'
-import { formatLinearMeasurement, MEASUREMENT_FLOORPLAN_COLOR } from '../../lib/measurements'
+import { MEASUREMENT_FLOORPLAN_COLOR } from '../../lib/measurements'
 import {
   commitRoomFloorElevation,
   roomRelativeFloorHeight,

package/src/components/editor/room-handles.tsx

@@ -3,13 +3,15 @@
 import {
   type AnyNodeId,
   clampRoomFloorHandle,
+  formatLinearMeasurement,
   type Point,
   roomDrawnFloor,
+  roomFloorElevation,
   sceneRegistry,
   usePascalI18n,
   useScene,
 } from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
+import { MEASUREMENT_ACTIVE_COLOR, useViewer } from '@pascal-app/viewer'
 import { type ThreeEvent, useFrame, useThree } from '@react-three/fiber'
 import { useEffect, useMemo, useRef, useState } from 'react'
 import {
@@ -35,7 +37,6 @@ import {
   resolveStructuralElevationSnap,
 } from '../../lib/elevation-guides'
 import { parseDimensionInput } from '../../lib/floorplan/dimension-drive'
-import { formatLinearMeasurement, MEASUREMENT_ACTIVE_COLOR } from '../../lib/measurements'
 import { commitRoomFloorElevation, roomFloorBase } from '../../lib/room-construction-commands'
 import {
   type MezzanineEdgeHandle,
@@ -44,7 +45,6 @@ import {
   ownFloorElevationBounds,
   ROOM_ELEVATION_DRAG_LABEL,
   type RoomHandleDrag,
-  roomFloorElevation,
   roomPushHandles,
   runMezzanineEdgeDrag,
   runRoomHandleDrag,

package/src/components/editor/room-labels.tsx

@@ -8,11 +8,15 @@ import {
   DEFAULT_LEVEL_HEIGHT,
   emitter,
   formatNumber,
+  getAreaUnitLabel,
+  type LinearUnit,
   type PascalI18n,
   type Polygon,
   polygonInteriorPoint,
   type Ring,
+  roomFloorElevation,
   sceneRegistry,
+  squareMetersToAreaUnit,
   useLocale,
   usePascalI18n,
   useScene,
@@ -48,8 +52,6 @@ import {
 } from 'three'
 import { useShallow } from 'zustand/react/shallow'
 import { useRoomRecords } from '../../hooks/use-selected-room'
-import { getAreaUnitLabel, type LinearUnit, squareMetersToAreaUnit } from '../../lib/measurements'
-import { roomFloorElevation } from '../../lib/room-handle-drag'
 import { displayRoomName } from '../../lib/room-name-messages'
 import type { RoomSelectionRecord } from '../../lib/room-selection'
 import { clickZoneArea, hoverZoneArea, leaveZoneArea } from '../../lib/room-zone-routing'

package/src/components/editor/site-edge-labels.tsx

@@ -1,13 +1,17 @@
 'use client'
 
 import type { SiteNode } from '@pascal-app/core'
-import { sceneRegistry, useLiveNodeOverrides, useScene } from '@pascal-app/core'
+import {
+  formatLinearMeasurement,
+  sceneRegistry,
+  useLiveNodeOverrides,
+  useScene,
+} from '@pascal-app/core'
 import { getSceneTheme, useViewer } from '@pascal-app/viewer'
 import { createPortal, useFrame, useThree } from '@react-three/fiber'
 import { useCallback, useMemo, useRef, useState } from 'react'
 import { type Camera, type Object3D, Vector3 } from 'three'
 import { groundHeightAt } from '../../lib/ground-surface'
-import { formatLinearMeasurement } from '../../lib/measurements'
 import { SITE_BOUNDARY_DRAG_LABEL } from '../../lib/site-boundary'
 import { useActiveHandleDrag } from '../../store/use-interaction-scope'
 import { Html } from './localized-html'

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

@@ -4,6 +4,7 @@ import {
   type AnyNode,
   type AnyNodeId,
   calculateLevelMiters,
+  formatLinearMeasurement,
   getWallCurveLength,
   getWallEffectiveHeightForNodes,
   getWallMiterBoundaryPoints,
@@ -23,7 +24,6 @@ import { getSceneTheme, useViewer } from '@pascal-app/viewer'
 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
@@ -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