@pascal-app/editor 1.0.7 → 1.1.1

package/src/components/editor/floorplan-navigation-presentation.ts

@@ -5,15 +5,6 @@ export type FloorplanPresentationViewBox = {
   height: number
 }
 
-export function setFloorplanCompassRotation(
-  compass: { style: { transform: string } } | null,
-  rotationDeg: number,
-): void {
-  if (compass) {
-    compass.style.transform = `rotate(${rotationDeg}deg)`
-  }
-}
-
 type FloorplanRotationPresentation = {
   svg: {
     style: {
@@ -78,63 +69,6 @@ export function canApplyFloorplanNavigationSync(interactionInProgress: boolean):
   return !interactionInProgress
 }
 
-export type FloorplanNavigationSyncScheduler<Pose> = {
-  update: (pose: Pose) => void
-  flush: () => void
-  discard: () => void
-}
-
-export function createFloorplanNavigationSyncScheduler<Pose>({
-  applyPresentation,
-  commit,
-  settleMs = 120,
-  schedule = globalThis.setTimeout,
-  cancel = globalThis.clearTimeout,
-}: {
-  applyPresentation: (pose: Pose) => void
-  commit: (pose: Pose) => void
-  settleMs?: number
-  schedule?: (callback: () => void, delay: number) => ReturnType<typeof globalThis.setTimeout>
-  cancel?: (timer: ReturnType<typeof globalThis.setTimeout>) => void
-}): FloorplanNavigationSyncScheduler<Pose> {
-  let latestPose: Pose | null = null
-  let settleTimer: ReturnType<typeof globalThis.setTimeout> | null = null
-
-  const clearSettleTimer = () => {
-    if (settleTimer === null) return
-    cancel(settleTimer)
-    settleTimer = null
-  }
-
-  const flush = () => {
-    clearSettleTimer()
-    if (latestPose === null) return
-    const pose = latestPose
-    latestPose = null
-    commit(pose)
-  }
-
-  const update = (pose: Pose) => {
-    latestPose = pose
-    applyPresentation(pose)
-    clearSettleTimer()
-    settleTimer = schedule(() => {
-      settleTimer = null
-      if (latestPose === null) return
-      const settledPose = latestPose
-      latestPose = null
-      commit(settledPose)
-    }, settleMs)
-  }
-
-  const discard = () => {
-    clearSettleTimer()
-    latestPose = null
-  }
-
-  return { update, flush, discard }
-}
-
 export function finalizeFloorplanNavigation<RotationState>({
   zoomPending,
   panActive,

package/src/components/editor/floorplan-panel.tsx

@@ -5,6 +5,8 @@ import {
   type AnyNode,
   type AnyNodeId,
   type BuildingNode,
+  buildFloorplanContext,
+  buildSvgPolylinePath,
   type CameraControlFrameEvent,
   type CeilingNode,
   CeilingNode as CeilingNodeSchema,
@@ -18,8 +20,13 @@ import {
   type ElevatorNode,
   emitter,
   type FenceNode,
+  FLOORPLAN_VIEW_ROTATION_DEG,
   type FloorplanGeometry,
+  floorplanLocalToWorldPoint,
+  formatAngleRadians,
+  formatLinearMeasurement,
   formatNumber as formatLocalizedNumber,
+  formatPolygonPath,
   type GeometryContext,
   type GuideNode,
   getRenderableSlabPolygon,
@@ -29,6 +36,7 @@ import {
   type ItemNode,
   isCurvedWall,
   type LevelNode,
+  linearUnitToMeters,
   loadAssetUrl,
   newZone,
   nodeRegistry,
@@ -38,6 +46,7 @@ import {
   type RoofSegmentNode,
   resolveSlabPlacementElevation,
   resolveTerrainWallConstructionOptions,
+  rotatePlanVector as rotateSharedPlanVector,
   runAsSingleSceneHistoryStep,
   type SeparatorNode,
   type SiteNode,
@@ -61,9 +70,24 @@ import {
   WindowNode as WindowNodeSchema,
   wallClosesRoom,
   wallRectangleCorners,
+  worldToFloorplanLocalPoint,
 } from '@pascal-app/core'
 import { useSegmentDraftChain, useWallSnapIndicator } from '@pascal-app/editor'
 import { getSceneTheme, useViewer } from '@pascal-app/viewer'
+import {
+  createFloorplanNavigationSyncScheduler,
+  FloorplanCompassButton,
+  FloorplanGeometryRenderer,
+  type FloorplanNavigationSyncScheduler,
+  framingAnimates,
+  type NavigationSyncPose,
+  navigationSyncPoseStore,
+  publishNavigationSyncPose,
+  setFloorplanCompassRotation,
+  subscribeFloorplanCameraNavigation,
+  subscribeNavigationSyncPose,
+  useFloorplanCameraSyncBridge,
+} from '@pascal-app/viewer/ui'
 import { Command, Ruler } from 'lucide-react'
 import {
   type ComponentProps,
@@ -92,14 +116,9 @@ import {
   alignFloorplanDraftPoint,
   buildFloorplanItemEntry,
   collectLevelDescendants,
-  FLOORPLAN_VIEW_ROTATION_DEG,
-  floorplanLocalToWorldPoint,
   getFloorplanWall as getSharedFloorplanWall,
-  rotatePlanVector as rotateSharedPlanVector,
   type FloorplanNodeTransform as SharedFloorplanNodeTransform,
-  worldToFloorplanLocalPoint,
 } from '../../lib/floorplan'
-import { buildFloorplanContext } from '../../lib/floorplan/floorplan-readonly'
 // Site-plan view. Owned under `lib/floorplan/site-plan/**`; this panel
 // only chooses between it and the registry layer, and mounts the switch.
 import {
@@ -124,7 +143,6 @@ import {
   syncKeyboardPanMotion,
 } from '../../lib/keyboard-pan'
 import { measurementHint, parseMeasurement } from '../../lib/measurement-parser'
-import { formatLinearMeasurement, linearUnitToMeters } from '../../lib/measurements'
 import {
   createGuideScaleReference,
   formatReferenceScaleLabel,
@@ -145,7 +163,6 @@ import {
   zoneAtLevelPoint,
 } from '../../lib/units'
 import { cn } from '../../lib/utils'
-import { framingAnimates } from '../../lib/viewer-selection'
 import {
   getWallDrawVariant,
   getWallLineKind,
@@ -174,10 +191,9 @@ import {
 } from '../../lib/wall-run-snap'
 import { snapBuildingLocalToWorldGrid } from '../../lib/world-grid-snap'
 import { nextZoneName } from '../../lib/zone-name'
-import { subscribeNavigationSyncPose } from '../../store/navigation-sync-pose-store'
 import useAlignmentGuides from '../../store/use-alignment-guides'
 import useDrawingView from '../../store/use-drawing-view'
-import type { GuideUiState, NavigationSyncPose } from '../../store/use-editor'
+import type { GuideUiState } from '../../store/use-editor'
 import useEditor, {
   isAngleSnapActive,
   isMagneticSnapActive,
@@ -193,6 +209,7 @@ import useInteractionScope, {
   useReshapingNode,
 } from '../../store/use-interaction-scope'
 import usePlacementPreview from '../../store/use-placement-preview'
+import { placementTypingLengthOptions, usePlacementTyping } from '../../store/use-placement-typing'
 import { expandSessionSelectionForNode } from '../../store/use-session-groups'
 import { useStairBuildPreview } from '../../store/use-stair-build-preview'
 import {
@@ -220,15 +237,14 @@ import { FloorplanSnapBeaconLayer } from '../editor-2d/floorplan-snap-beacon-lay
 import { FloorplanWallMoveGhostLayer } from '../editor-2d/floorplan-wall-move-ghost-layer'
 import { FloorplanDraftLayer } from '../editor-2d/renderers/floorplan-draft-layer'
 import { FloorplanDraftMeasurement } from '../editor-2d/renderers/floorplan-draft-measurement'
-import { FloorplanGeometryRenderer } from '../editor-2d/renderers/floorplan-geometry-renderer'
 import { FloorplanMarqueeLayer } from '../editor-2d/renderers/floorplan-marquee-layer'
 import { FloorplanPlacementPreviewLayer } from '../editor-2d/renderers/floorplan-placement-preview-layer'
+import { FloorplanPlacementTypingHud } from '../editor-2d/renderers/floorplan-placement-typing-hud'
 import {
   FloorplanRegistryLayer,
   RotationAngleOverlay,
 } from '../editor-2d/renderers/floorplan-registry-layer'
 import { FloorplanVoronoiLayer } from '../editor-2d/renderers/floorplan-voronoi-layer'
-import { buildSvgPolylinePath, formatPolygonPath } from '../editor-2d/svg-paths'
 import { snapToHalf } from '../tools/item/placement-math'
 import {
   isBoxSelectPointerSuppressed,
@@ -253,7 +269,6 @@ import {
 } from '../tools/select/screen-rectangle-selection'
 import { collectSelectableCandidateIds } from '../tools/select/select-candidates'
 import {
-  formatAngleRadians,
   getAngleArcToSegmentReference,
   getAngleToSegmentReference,
   getSegmentAngleReferenceAtPoint,
@@ -262,6 +277,7 @@ import {
   chainEndJoinsExistingWall,
   createInvisibleWallOnCurrentLevel,
   createWallOnCurrentLevel,
+  getSegmentGridStep,
   isSegmentLongEnough,
   snapWallDraftPoint,
   snapWallDraftPointDetailed,
@@ -270,25 +286,22 @@ import {
   WALL_JOIN_SNAP_RADIUS,
   type WallPlanPoint,
 } from '../tools/wall/wall-drafting'
-import { FloorplanCompassButton } from '../viewer/floorplan-compass-button'
+import { formatWallDraftHeading, resolveTypedWallEnd } from '../tools/wall/wall-typed-entry'
 import { resolveFloorplanBackgroundSelection } from './floorplan-background-selection'
-import {
-  subscribeFloorplanCameraNavigation,
-  useFloorplanCameraSyncBridge,
-} from './floorplan-camera-sync'
 import {
   canApplyFloorplanNavigationSync,
   canZoomFloorplanDuringNavigation,
-  createFloorplanNavigationSyncScheduler,
-  type FloorplanNavigationSyncScheduler,
   type FloorplanPresentationViewBox,
   finalizeFloorplanNavigation,
   flushFloorplanRotationPresentationRestore,
   getFloorplanRotationOverscanViewBox,
   queueFloorplanRotationPresentationRestore,
   resolveFloorplanPresentationViewBox,
-  setFloorplanCompassRotation,
 } from './floorplan-navigation-presentation'
+import {
+  endFloorplanWallTypingOnCancel,
+  installFloorplanWallTypingKeys,
+} from './floorplan-wall-typing-keys'
 import { swallowNextClick } from './handles/use-handle-drag'
 import { useFloorplanBackgroundPlacement } from './use-floorplan-background-placement'
 import { useFloorplanHitTesting } from './use-floorplan-hit-testing'
@@ -4503,6 +4516,7 @@ function FloorplanLinearDraftLayer({
   // The thickness the wall commits at, as the 3D draft shows it.
   const wallDraftThickness = useWallDraftThickness(DEFAULT_WALL_THICKNESS)
   const wallDraftEnd = useFloorplanDraftPreview((s) => s.wallDraftEnd)
+  const wallTypingActive = usePlacementTyping((s) => s.isActive)
   const fenceDraftEnd = useFloorplanDraftPreview((s) => s.fenceDraftEnd)
   const roofDraftEnd = useFloorplanDraftPreview((s) => s.roofDraftEnd)
   const roofDraftQuarterTurn = useFloorplanDraftPreview((s) => s.roofDraftQuarterTurn)
@@ -4828,6 +4842,7 @@ function FloorplanLinearDraftLayer({
         <FloorplanDraftMeasurement
           labelBackground={isDark ? '#0f172a' : '#ffffff'}
           labelText={isDark ? '#e2e8f0' : '#171717'}
+          lengthHidden={wallTypingActive}
           measurement={draftWallMeasurement}
           measurementStroke={measurementStroke}
           sceneRotationDeg={sceneRotationDeg}
@@ -4835,6 +4850,19 @@ function FloorplanLinearDraftLayer({
         />
       )}
 
+      {wallTypingActive && isWallBuildActive && wallDraftStart ? (
+        <FloorplanPlacementTypingHud
+          placeholders={[
+            draftWallMeasurement?.lengthLabel ?? '',
+            wallDraftEnd ? formatWallDraftHeading(wallDraftStart, wallDraftEnd) : '',
+          ]}
+          sceneRotationDeg={sceneRotationDeg}
+          unitsPerPixel={unitsPerPixel}
+          x={(draftWallMeasurement?.midpoint ?? wallDraftStart)[0]}
+          y={(draftWallMeasurement?.midpoint ?? wallDraftStart)[1]}
+        />
+      ) : null}
+
       {polygonRoomDraft?.map((points, index) => (
         <FloorplanDraftLayer
           anchorFill={draftStroke}
@@ -4889,7 +4917,7 @@ const DRAFT_AXIS_GUIDE_EXTENT = 1000
 export function FloorplanPanel({
   /**
    * Element to portal the compass button into. The 2D/3D navigation poses stay
-   * in sync (`navigationSyncPose`), so hosting the compass on the always-visible
+   * in sync (`navigationSyncPoseStore`), so hosting the compass on the always-visible
    * viewer-area container keeps it correct — needle and align-to-north alike —
    * in 2d, 3d, and split modes, while this panel itself may be display:none.
    */
@@ -4912,6 +4940,9 @@ export function FloorplanPanel({
   const floorplanSpacePanPressedRef = useRef(false)
   const floorplanNavigationClickSuppressedRef = useRef(false)
   const guideInteractionRef = useRef<GuideInteractionState | null>(null)
+  // Late-bound so the window keydown effect can commit the wall draft at the
+  // typed length without an ordering dependency on `handleWallPlacementPoint`.
+  const wallPlacementPointRef = useRef<((point: WallPlanPoint) => void) | null>(null)
   const guideTransformDraftRef = useRef<GuideTransformDraft | null>(null)
   const pendingFenceDragRef = useRef<PendingFenceDragState | null>(null)
   const wallEndpointDragRef = useRef<WallEndpointDragState | null>(null)
@@ -4958,7 +4989,7 @@ export function FloorplanPanel({
     viewWidth: number
   } | null>(null)
   const latestNavigationSyncPoseRef = useRef<NavigationSyncPose | null>(
-    useEditor.getState().navigationSyncPose,
+    navigationSyncPoseStore.getState().pose,
   )
   const compassNeedleRef = useRef<SVGSVGElement | null>(null)
   const hiddenCompassAnimationRef = useRef<number | null>(null)
@@ -5105,6 +5136,25 @@ export function FloorplanPanel({
   // Walls committed by the current 2D-only chain — exclusion set for the
   // T-junction chain-termination test (mirrors the 3D tool's `chainWallIds`).
   const wallChainWallIdsRef = useRef<string[]>([])
+  // Split view: the 3D wall tool owns the commit and publishes each segment's
+  // resolved end as the chain start. Re-base this panel's draft onto it so a
+  // typed Enter in the plan projects from the segment the 3D chain is
+  // actually drafting — without this, `draftStart` stays on the last point
+  // the panel itself placed and the typed commit uses a stale origin. In
+  // 2D-only the panel is the committer and never publishes, so this
+  // subscription stays dormant there.
+  useEffect(() => {
+    if (!(mode === 'build' && tool === 'wall')) return
+    return useSegmentDraftChain.subscribe((state, previousState) => {
+      const next = state.wall
+      if (next === previousState.wall) return
+      if (!next) return
+      setDraftStart((current) =>
+        current && current[0] === next[0] && current[1] === next[1] ? current : next,
+      )
+      setWallChainFirstVertex((current) => current ?? next)
+    })
+  }, [mode, tool])
   // Direction of the run's last wall (a pulled run's source first): the next
   // holds square to it. Null before the run has a wall.
   const wallRunReferenceRef = useRef<WallPlanPoint | null>(null)
@@ -5115,6 +5165,8 @@ export function FloorplanPanel({
     },
     [],
   )
+  // The pointer's own (snapped) wall draft end; a typed session re-projects it.
+  const wallDraftPointerRef = useRef<WallPlanPoint | null>(null)
   const [fenceDraftStart, setFenceDraftStart] = useState<WallPlanPoint | null>(null)
   const setFenceDraftEnd = useCallback(
     (next: WallPlanPoint | null | ((prev: WallPlanPoint | null) => WallPlanPoint | null)) => {
@@ -7358,7 +7410,7 @@ export function FloorplanPanel({
       )
       const targetY = latestNavigationSyncPoseRef.current?.target[1] ?? floorplanGridWorldY
 
-      useEditor.getState().publishNavigationSyncPose({
+      publishNavigationSyncPose({
         source: '2d',
         target: [worldCenter.x, targetY, worldCenter.z],
         azimuth: cameraAzimuthFromFloorplanRotation(userRotationDeg),
@@ -7379,7 +7431,7 @@ export function FloorplanPanel({
       const northAzimuth = cameraAzimuthFromFloorplanRotation(
         nearestEquivalentDegrees(0, currentRotation),
       )
-      useEditor.getState().publishNavigationSyncPose({
+      publishNavigationSyncPose({
         source: '2d',
         target: [...pose.target],
         azimuth: northAzimuth,
@@ -7916,6 +7968,26 @@ export function FloorplanPanel({
     }
   }, [isFloorplanOpen, stopFloorplanViewAnimation])
 
+  // Typing reshapes the plan's own draft without a pointer move.
+  useEffect(() => {
+    if (!draftStart) return
+    return usePlacementTyping.subscribe((state, previous) => {
+      if (state.fields === previous.fields && state.isActive === previous.isActive) return
+      const pointer = wallDraftPointerRef.current
+      if (!pointer) return
+      setDraftEnd(
+        (state.isActive &&
+          resolveTypedWallEnd(
+            draftStart,
+            pointer,
+            state.fields,
+            placementTypingLengthOptions(unit, metricNotation),
+            getSegmentGridStep(),
+          )) ||
+          pointer,
+      )
+    })
+  }, [draftStart, metricNotation, setDraftEnd, unit])
   // Clearing an open wall draft drops a Polygon room in progress (nothing of
   // it was written); paths that keep it commit first.
   const clearWallPlacementDraft = useCallback(() => {
@@ -7926,6 +7998,8 @@ export function FloorplanPanel({
     wallChainWallIdsRef.current = []
     wallRunReferenceRef.current = null
     setDraftEnd(null)
+    wallDraftPointerRef.current = null
+    usePlacementTyping.getState().clear()
     useSegmentDraftChain.getState().clear('wall')
     // A run pulled from a wall end ends with the plan's draft: back to Select.
     endWallPullRun()
@@ -8033,6 +8107,7 @@ export function FloorplanPanel({
 
   useEffect(() => {
     const handleCancel = () => {
+      if (endFloorplanWallTypingOnCancel()) return
       clearDraft()
     }
 
@@ -8042,6 +8117,20 @@ export function FloorplanPanel({
     }
   }, [clearDraft])
 
+  // Split view: when the 3D wall tool stops drafting (auto-close,
+  // T-junction, single-segment, cancel) it clears the published chain start.
+  // That null clear must tear this panel's draft down too, or the 2D side
+  // keeps a live draft that swallows typing keys against a chain the 3D
+  // view already ended. Lives here (below `clearDraft`)
+  // rather than beside the re-base subscription so the teardown stays
+  // reachable.
+  useEffect(() => {
+    if (!(mode === 'build' && tool === 'wall')) return
+    return useSegmentDraftChain.subscribe((state, previousState) => {
+      if (state.wall === null && previousState.wall !== null) clearDraft()
+    })
+  }, [mode, tool, clearDraft])
+
   // A wall end's pull grip pressed in the plan opens the Walls run at that
   // end: start the plan's draft there, as if the end had been clicked. A pull
   // from the 3D view drafts there (the plan beside it follows its moves).
@@ -8315,6 +8404,31 @@ export function FloorplanPanel({
     return unsubscribe
   }, [movingNode, scheduleMovingFloorplanNodeRefresh])
 
+  // Read by the typed-entry listener, registered once so it stays ahead of
+  // the global shortcuts.
+  const wallTypingSourceRef = useRef({
+    draftStart: null as WallPlanPoint | null,
+    lengthOptions: placementTypingLengthOptions(unit, metricNotation),
+  })
+  wallTypingSourceRef.current = {
+    draftStart: isWallBuildActive ? draftStart : null,
+    lengthOptions: placementTypingLengthOptions(unit, metricNotation),
+  }
+  useEffect(
+    () =>
+      installFloorplanWallTypingKeys({
+        getDraft: () => {
+          const { draftStart: start, lengthOptions } = wallTypingSourceRef.current
+          if (!start) return null
+          const pointer =
+            wallDraftPointerRef.current ?? useFloorplanDraftPreview.getState().wallDraftEnd ?? start
+          return { start, pointer, lengthOptions }
+        },
+        commit: (pointer) => wallPlacementPointRef.current?.(pointer),
+      }),
+    [],
+  )
+
   useEffect(() => {
     const handleKeyDown = (event: KeyboardEvent) => {
       const target = event.target as HTMLElement | null
@@ -8393,7 +8507,16 @@ export function FloorplanPanel({
       window.removeEventListener('keyup', handleKeyUp)
       window.removeEventListener('blur', handleBlur)
     }
-  }, [isFloorplanOpen, isStairBuildActive, movingNode])
+  }, [
+    isFloorplanOpen,
+    isStairBuildActive,
+    movingNode,
+    isWallBuildActive,
+    draftStart,
+    unit,
+    metricNotation,
+    setDraftEnd,
+  ])
 
   useEffect(() => {
     const handleWindowPointerMove = (event: PointerEvent) => {
@@ -9653,8 +9776,23 @@ export function FloorplanPanel({
       // Emit `grid:move` so the registry-driven wall tool's 3D preview
       // tracks the cursor. The local draftEnd update below is what
       // drives the 2D draft polygon — both views update in parallel.
+      // An open typed session re-projects the pointer onto what was typed;
+      // the 3D tool gets the pointer itself and projects it the same way.
+      wallDraftPointerRef.current = draftStart ? snappedPoint : null
+      const wallTyping = usePlacementTyping.getState()
+      const draftEndPoint =
+        (draftStart &&
+          wallTyping.isActive &&
+          resolveTypedWallEnd(
+            draftStart,
+            snappedPoint,
+            wallTyping.fields,
+            placementTypingLengthOptions(unit, metricNotation),
+            getSegmentGridStep(),
+          )) ||
+        snappedPoint
       emitFloorplanGridEvent('move', snappedPoint, event)
-      setCursorPoint(snappedPoint)
+      setCursorPoint(draftEndPoint)
 
       if (!draftStart) {
         return
@@ -9663,13 +9801,13 @@ export function FloorplanPanel({
       setDraftEnd((previousEnd) => {
         if (
           !previousEnd ||
-          previousEnd[0] !== snappedPoint[0] ||
-          previousEnd[1] !== snappedPoint[1]
+          previousEnd[0] !== draftEndPoint[0] ||
+          previousEnd[1] !== draftEndPoint[1]
         ) {
           sfxEmitter.emit('sfx:grid-snap')
         }
 
-        return snappedPoint
+        return draftEndPoint
       })
     },
     [
@@ -9704,6 +9842,11 @@ export function FloorplanPanel({
       isRoofBuildActive,
       isWallBuildActive,
       levelId,
+      // `unit` / `metricNotation` feed the typed-length projection helpers
+      // shared with the commit path; listed so a unit change re-binds the
+      // move preview to the new bare-unit parse.
+      metricNotation,
+      unit,
       publishFloorplanNavigationPose,
       referenceScaleDraft,
       siteVertexDragState,
@@ -9889,7 +10032,21 @@ export function FloorplanPanel({
   )
 
   const handleWallPlacementPoint = useCallback(
-    (point: WallPlanPoint) => {
+    (rawPoint: WallPlanPoint) => {
+      // An open typed session commits what its preview shows: the pointer
+      // re-projected onto what was typed, never re-snapped.
+      const typing = usePlacementTyping.getState()
+      const typedEnd =
+        draftStart && typing.isActive
+          ? resolveTypedWallEnd(
+              draftStart,
+              rawPoint,
+              typing.fields,
+              placementTypingLengthOptions(unit, metricNotation),
+              getSegmentGridStep(),
+            )
+          : null
+      const point: WallPlanPoint = typedEnd ?? rawPoint
       if (!draftStart) {
         wallConstructionOptionsRef.current = levelId
           ? resolveTerrainWallConstructionOptions(
@@ -9950,6 +10107,7 @@ export function FloorplanPanel({
         setDraftStart(point)
         setDraftEnd(point)
         setCursorPoint(point)
+        usePlacementTyping.getState().clear()
         return
       }
       if (viewIs2DOnly) {
@@ -10015,16 +10173,26 @@ export function FloorplanPanel({
       setDraftStart(nextStart)
       setDraftEnd(nextStart)
       setCursorPoint(nextStart)
+      // What was typed belongs to this segment; the next starts afresh.
+      usePlacementTyping.getState().clear()
     },
     [
       clearWallPlacementDraft,
       draftStart,
       levelId,
+      metricNotation,
+      unit,
       wallChainFirstVertex,
       setDraftEnd,
       setCursorPoint,
     ],
   )
+  // Latest-ref for the Enter-commit path: assigning the ref inside the
+  // callback itself froze the first-render closure (draftStart === null), so
+  // a typed Enter re-started the draft instead of committing the wall.
+  useEffect(() => {
+    wallPlacementPointRef.current = handleWallPlacementPoint
+  }, [handleWallPlacementPoint])
   const { getFloorplanHitIdAtPoint, getFloorplanSelectionIdsInBounds } = useFloorplanHitTesting({
     sceneRef: floorplanSceneRef,
   })
@@ -10254,6 +10422,7 @@ export function FloorplanPanel({
       unit,
       emitFloorplanGridEvent,
       setCursorPoint,
+      locale,
     ],
   )
   const handleSvgClick = useCallback(