@pascal-app/editor 1.0.7 → 1.1.0

package/src/components/editor/fit-scene-framing.ts

@@ -0,0 +1,142 @@
+export type FitSceneBounds = {
+  center: [number, number]
+  size: [number, number]
+} | null
+
+export type FitSceneLookAt = {
+  eyeX: number
+  eyeY: number
+  eyeZ: number
+  targetX: number
+  targetY: number
+  targetZ: number
+  /** The eye's height above `targetY`, before any keep-over-ground lift. */
+  eyeHeight: number
+  /**
+   * What an orthographic camera fits its zoom to: `setLookAt` leaves the
+   * previous project's zoom in place. Centred on the target, so fitting it
+   * does not move the pivot.
+   */
+  fitSphere: { center: [number, number, number]; radius: number }
+}
+
+// The empty-editor pose shows the default ±15 m site.
+const DEFAULT_FIT_RADIUS = 15
+// Margin around the footprint, as the frame-node path uses for orthographic fits.
+const FIT_SPHERE_MARGIN = 1.3
+// Keeps a lone wall from filling the viewport, like the perspective 15 m floor.
+const MIN_FIT_RADIUS = 5
+
+export type PendingFitScene = {
+  bounds: FitSceneBounds
+}
+
+export type FitSceneEventPlan =
+  | { action: 'ignore' }
+  | { action: 'apply'; lookAt: FitSceneLookAt }
+  | { action: 'queue'; pending: PendingFitScene }
+
+export type FitSceneResumePlan = { action: 'noop' } | { action: 'apply'; lookAt: FitSceneLookAt }
+
+/**
+ * Compute the orbit look-at used by `camera-controls:fit-scene`, resting the
+ * pivot at `groundY` (the selected level's orbit height).
+ * Null bounds restore the empty-editor default pose.
+ */
+export function computeFitSceneLookAt(bounds: FitSceneBounds, groundY = 0): FitSceneLookAt {
+  if (!bounds) {
+    return {
+      eyeX: 20,
+      eyeY: 20 + groundY,
+      eyeZ: 20,
+      targetX: 0,
+      targetY: groundY,
+      targetZ: 0,
+      eyeHeight: 20,
+      fitSphere: { center: [0, groundY, 0], radius: DEFAULT_FIT_RADIUS },
+    }
+  }
+
+  const [cx, cz] = bounds.center
+  const [w, d] = bounds.size
+  // Use the longer horizontal extent to size the orbit radius so the whole
+  // footprint sits in view regardless of aspect ratio.
+  const maxExtent = Math.max(w, d)
+  const distance = Math.max(maxExtent * 1.4, 15)
+  const height = Math.max(maxExtent * 0.8, 10)
+  return {
+    eyeX: cx + distance * 0.7,
+    eyeY: height + groundY,
+    eyeZ: cz + distance * 0.7,
+    targetX: cx,
+    targetY: groundY,
+    targetZ: cz,
+    eyeHeight: height,
+    fitSphere: {
+      center: [cx, groundY, cz],
+      radius: Math.max((Math.hypot(w, d) / 2) * FIT_SPHERE_MARGIN, MIN_FIT_RADIUS),
+    },
+  }
+}
+
+/**
+ * Decide what to do when a fit-scene event arrives.
+ * First-person (and briefly-unmounted orbit controls) must queue the frame
+ * so it can apply once orbit is back.
+ */
+export function planFitSceneOnEvent(input: {
+  isPreviewMode: boolean
+  isFirstPersonMode: boolean
+  hasControls: boolean
+  bounds: FitSceneBounds
+  groundY?: number
+}): FitSceneEventPlan {
+  if (input.isPreviewMode) return { action: 'ignore' }
+
+  const pending: PendingFitScene = { bounds: input.bounds }
+  if (input.isFirstPersonMode || !input.hasControls) {
+    return { action: 'queue', pending }
+  }
+
+  return { action: 'apply', lookAt: computeFitSceneLookAt(input.bounds, input.groundY) }
+}
+
+/**
+ * Flush a queued load frame once orbit controls can apply it. The ground is
+ * read at flush time: the selected level may have changed while it waited.
+ */
+export function planFitSceneOnOrbitResume(input: {
+  isPreviewMode: boolean
+  isFirstPersonMode: boolean
+  hasControls: boolean
+  pending: PendingFitScene | null
+  groundY?: number
+}): FitSceneResumePlan {
+  if (!input.pending || input.isPreviewMode || input.isFirstPersonMode || !input.hasControls) {
+    return { action: 'noop' }
+  }
+
+  return { action: 'apply', lookAt: computeFitSceneLookAt(input.pending.bounds, input.groundY) }
+}
+
+export type LevelFollowPlan = 'none' | 'default-pose' | 'rest-pivot'
+
+/**
+ * What the level-follow effect does with the orbit pivot.
+ *
+ * Only a scene-less first run takes the default pose. A first run over a
+ * loaded scene is a fresh controls instance (mount, leaving XR, error-boundary
+ * recovery) whose pivot sits at the origin, so it is rested on the level like
+ * a camera change; on a real load the later scene-ready fit still wins.
+ * Afterwards the pivot follows level, level-mode and camera changes only.
+ */
+export function planLevelFollow(input: {
+  firstLoad: boolean
+  sceneEmpty: boolean
+  levelChanged: boolean
+  modeChanged: boolean
+  cameraChanged: boolean
+}): LevelFollowPlan {
+  if (input.firstLoad) return input.sceneEmpty ? 'default-pose' : 'rest-pivot'
+  return input.levelChanged || input.modeChanged || input.cameraChanged ? 'rest-pivot' : 'none'
+}

package/src/components/editor/floating-action-menu.tsx

@@ -14,6 +14,7 @@ import {
   getWallThickness,
   isCurvedWall,
   isDerivedNode,
+  isNodeDuplicable,
   isRegistryMovable,
   isRegistrySelectable,
   isSplineFence,
@@ -284,7 +285,7 @@ function getHeightPillDimensions(node: WallNode | FenceNode): {
 } {
   if (node.type === 'wall') {
     return {
-      height: getWallEffectiveHeightForNodes(node, useScene.getState().nodes),
+      height: getWallEffectiveHeightForNodes(node, useScene.getState().nodes, 0),
       length: getWallCurveLength(node),
       thickness: getWallThickness(node),
     }
@@ -423,7 +424,7 @@ export function FloatingActionMenu() {
         | undefined
       const fallbackHeight =
         node.type === 'wall'
-          ? getWallEffectiveHeightForNodes(node, useScene.getState().nodes)
+          ? getWallEffectiveHeightForNodes(node, useScene.getState().nodes, 0)
           : FENCE_DEFAULT_HEIGHT
       const liveHeight = override?.height ?? node.height ?? fallbackHeight
       pillHeightRef.current.textContent = `H ${formatMeasurement(liveHeight, unit, metricNotation)}`
@@ -681,6 +682,7 @@ export function FloatingActionMenu() {
                 onDelete={handleDelete}
                 onDuplicate={
                   node &&
+                  isNodeDuplicable(node as AnyNode) &&
                   node.type !== 'spawn' &&
                   !DELETE_ONLY_TYPES.includes(node.type) &&
                   !HOLE_TYPES.includes(node.type)

package/src/components/editor/floor-openings-overlay.tsx

@@ -5,6 +5,7 @@ import {
   type AnyNodeId,
   type FloorOpeningNode,
   resolveCeilingHeight,
+  roomFloorElevation,
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
@@ -24,7 +25,6 @@ import { useCeilingEditSession } from '../../lib/ceiling-edit-session'
 import { EDITOR_LAYER } from '../../lib/constants'
 import { openingRoom, roomSurfaceOpenings, useFloorEditSession } from '../../lib/floor-edit-session'
 import { useOpeningDraft } from '../../lib/floor-opening-draft'
-import { roomFloorElevation } from '../../lib/room-handle-drag'
 import { PolygonEditor } from '../tools/shared/polygon-editor'
 
 // The openings of the room being edited ("Edit floor", "Edit ceiling", or a

package/src/components/editor/floor-region-controls.tsx

@@ -3,8 +3,10 @@
 import {
   containsPoint,
   emitter,
+  formatAreaLabel,
   type MultiPolygon,
   resolveCeilingHeight,
+  roomFloorElevation,
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
@@ -60,14 +62,12 @@ import {
 } from '../../lib/floor-region-session'
 import { type FloorRegionPoint, snapFloorRegionPoint } from '../../lib/floor-region-snap'
 import { clientToPlan } from '../../lib/floorplan/plan-coords'
-import { formatAreaLabel } from '../../lib/measurements'
 import {
   cancelMezzanineDraft,
   mezzanineDraftActive,
   useMezzanineDraft,
 } from '../../lib/mezzanine-draft'
 import { usePaintRegionMode } from '../../lib/paint-region-mode'
-import { roomFloorElevation } from '../../lib/room-handle-drag'
 import {
   cancelTerraceDraft,
   terraceDraftActive,

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

@@ -19,6 +19,8 @@ import {
   emitter,
   type FenceNode,
   type FloorplanGeometry,
+  formatAngleRadians,
+  formatLinearMeasurement,
   formatNumber as formatLocalizedNumber,
   type GeometryContext,
   type GuideNode,
@@ -29,6 +31,7 @@ import {
   type ItemNode,
   isCurvedWall,
   type LevelNode,
+  linearUnitToMeters,
   loadAssetUrl,
   newZone,
   nodeRegistry,
@@ -124,7 +127,6 @@ import {
   syncKeyboardPanMotion,
 } from '../../lib/keyboard-pan'
 import { measurementHint, parseMeasurement } from '../../lib/measurement-parser'
-import { formatLinearMeasurement, linearUnitToMeters } from '../../lib/measurements'
 import {
   createGuideScaleReference,
   formatReferenceScaleLabel,
@@ -193,6 +195,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 {
@@ -223,6 +226,7 @@ import { FloorplanDraftMeasurement } from '../editor-2d/renderers/floorplan-draf
 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,
@@ -253,7 +257,6 @@ import {
 } from '../tools/select/screen-rectangle-selection'
 import { collectSelectableCandidateIds } from '../tools/select/select-candidates'
 import {
-  formatAngleRadians,
   getAngleArcToSegmentReference,
   getAngleToSegmentReference,
   getSegmentAngleReferenceAtPoint,
@@ -262,6 +265,7 @@ import {
   chainEndJoinsExistingWall,
   createInvisibleWallOnCurrentLevel,
   createWallOnCurrentLevel,
+  getSegmentGridStep,
   isSegmentLongEnough,
   snapWallDraftPoint,
   snapWallDraftPointDetailed,
@@ -270,6 +274,7 @@ import {
   WALL_JOIN_SNAP_RADIUS,
   type WallPlanPoint,
 } from '../tools/wall/wall-drafting'
+import { formatWallDraftHeading, resolveTypedWallEnd } from '../tools/wall/wall-typed-entry'
 import { FloorplanCompassButton } from '../viewer/floorplan-compass-button'
 import { resolveFloorplanBackgroundSelection } from './floorplan-background-selection'
 import {
@@ -289,6 +294,10 @@ import {
   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 +4512,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 +4838,7 @@ function FloorplanLinearDraftLayer({
         <FloorplanDraftMeasurement
           labelBackground={isDark ? '#0f172a' : '#ffffff'}
           labelText={isDark ? '#e2e8f0' : '#171717'}
+          lengthHidden={wallTypingActive}
           measurement={draftWallMeasurement}
           measurementStroke={measurementStroke}
           sceneRotationDeg={sceneRotationDeg}
@@ -4835,6 +4846,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}
@@ -4912,6 +4936,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)
@@ -5105,6 +5132,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 +5161,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)) => {
@@ -7916,6 +7964,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 +7994,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 +8103,7 @@ export function FloorplanPanel({
 
   useEffect(() => {
     const handleCancel = () => {
+      if (endFloorplanWallTypingOnCancel()) return
       clearDraft()
     }
 
@@ -8042,6 +8113,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 +8400,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 +8503,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 +9772,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 +9797,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 +9838,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 +10028,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 +10103,7 @@ export function FloorplanPanel({
         setDraftStart(point)
         setDraftEnd(point)
         setCursorPoint(point)
+        usePlacementTyping.getState().clear()
         return
       }
       if (viewIs2DOnly) {
@@ -10015,16 +10169,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 +10418,7 @@ export function FloorplanPanel({
       unit,
       emitFloorplanGridEvent,
       setCursorPoint,
+      locale,
     ],
   )
   const handleSvgClick = useCallback(