@pascal-app/editor 1.0.7 → 1.1.1

package/src/components/editor-2d/floorplan-registry-action-menu.tsx

@@ -7,6 +7,7 @@ import {
   collectionIdsOf,
   createSceneApi,
   getWallMidpointHandlePoint,
+  isNodeDuplicable,
   type NodeQuickAction,
   nodeRegistry,
   runAsSingleSceneHistoryStep,
@@ -255,7 +256,7 @@ export function FloorplanRegistryActionMenu() {
   const canMove =
     !registryMoveDisabled(node) &&
     (!!def.capabilities.movable || !!def.floorplanMoveTarget || !!def.affordanceTools?.move)
-  const canDuplicate = def.capabilities.duplicable !== false
+  const canDuplicate = isNodeDuplicable(node)
   const canDelete = def.capabilities.deletable !== false
   const canAddHole = node.type === 'slab' || node.type === 'ceiling'
 

package/src/components/editor-2d/floorplan-registry-move-overlay.tsx

@@ -26,7 +26,7 @@ import {
   useScene,
 } from '@pascal-app/core'
 import { nodeLevelFrame } from '@pascal-app/core/procedural-items'
-import { useViewer } from '@pascal-app/viewer'
+import { isTypingTarget, useViewer } from '@pascal-app/viewer'
 import { useEffect, useMemo } from 'react'
 import { commitFreshPlacementSubtree } from '../../lib/fresh-planar-placement'
 import { isHistoryShortcut } from '../../lib/history'
@@ -39,7 +39,6 @@ import {
 import { movementSfxStepKey } from '../../lib/sfx/movement-tick'
 import { sfxEmitter } from '../../lib/sfx-bus'
 import { surfaceAttachmentId } from '../../lib/surface-attachment'
-import { isTypingTarget } from '../../lib/typing-target'
 import { resolveAlignmentForFloorplanView } from '../../lib/world-grid-snap'
 import useAlignmentGuides from '../../store/use-alignment-guides'
 import useEditor, {
@@ -850,14 +849,25 @@ export function FloorplanRegistryMoveOverlay() {
       }
       boxEl.setAttribute('transform', transform)
       const oldY = originalPosition[1]
+      const position = nodeRegistry.get(movingNode.type)?.capabilities?.movable?.resolvePosition?.({
+        node: useScene.getState().nodes[movingNode.id] ?? movingNode,
+        position: [finalX, oldY, finalZ],
+        nodes: useScene.getState().nodes,
+      }) ?? [finalX, oldY, finalZ]
+      if (def?.capabilities?.movable?.resolvePosition) {
+        useLiveTransforms.getState().set(movingNode.id, {
+          position: position as [number, number, number],
+          rotation: currentRotation,
+        })
+      }
       lastPositionValid = movableValidityConfig?.isValidPosition
         ? movableValidityConfig.isValidPosition({
             node: {
               ...movingNode,
-              position: [finalX, oldY, finalZ],
+              position,
               rotation: currentRotation,
             } as AnyNode,
-            position: [finalX, oldY, finalZ],
+            position: position as [number, number, number],
             rotation: currentRotation,
             levelId:
               (useViewer.getState().selection.levelId as AnyNodeId | null) ??
@@ -885,6 +895,11 @@ export function FloorplanRegistryMoveOverlay() {
             (storedRotation as [number?, number?, number?])[2] ?? 0,
           ]
         : snapped.rotation
+      const position = nodeRegistry.get(movingNode.type)?.capabilities?.movable?.resolvePosition?.({
+        node: useScene.getState().nodes[movingNode.id] ?? movingNode,
+        position: [sx, oldY, sz],
+        nodes: useScene.getState().nodes,
+      }) ?? [sx, oldY, sz]
       const rotationPatch = 'rotation' in movingNode ? { rotation } : {}
       const atomicPreview =
         isFreshPlacement &&
@@ -937,7 +952,7 @@ export function FloorplanRegistryMoveOverlay() {
         const committedId = commitFreshPlacementSubtree(
           movingNode.id as AnyNodeId,
           {
-            position: [sx, oldY, sz],
+            position,
             ...rotationPatch,
             metadata: stripPlacementMetadataFlags((movingNode as { metadata?: unknown }).metadata),
             visible: true,
@@ -953,7 +968,7 @@ export function FloorplanRegistryMoveOverlay() {
         useScene.getState().updateNode(
           movingNode.id as AnyNodeId,
           {
-            position: [sx, oldY, sz],
+            position,
             ...rotationPatch,
           } as Partial<AnyNode>,
         )
@@ -1005,6 +1020,8 @@ export function FloorplanRegistryMoveOverlay() {
       for (const relatedEntry of relatedEntries) {
         relatedEntry.style.visibility = ''
       }
+      if (def?.capabilities?.movable?.resolvePosition)
+        useLiveTransforms.getState().clear(movingNode.id)
       boxEl.remove()
       useAlignmentGuides.getState().clear()
     }

package/src/components/editor-2d/renderers/floorplan-annotation-layout.test.ts

@@ -1,47 +1,10 @@
 import { describe, expect, test } from 'bun:test'
-import { floorplanGeometryMetadata } from '../../../lib/floorplan/floorplan-extension'
 import {
-  floorplanAnnotationObstacleMode,
   polylineObstacleRectangles,
   resolveAnnotationLabelRectangles,
   resolveSvgAnnotationCollisions,
 } from './floorplan-annotation-layout'
 
-describe('floorplanAnnotationObstacleMode', () => {
-  test('treats fixed annotation categories as layout obstacles', () => {
-    expect(
-      floorplanAnnotationObstacleMode({
-        kind: 'text',
-        x: 0,
-        y: 0,
-        text: 'BEDROOM',
-        fontSize: 0.18,
-        metadata: floorplanGeometryMetadata({ annotationRole: 'room-label' }),
-      }),
-    ).toBe('bounds')
-    expect(
-      floorplanAnnotationObstacleMode({
-        kind: 'line',
-        x1: 0,
-        y1: 0,
-        x2: 1,
-        y2: 0,
-        metadata: floorplanGeometryMetadata({ annotationRole: 'column-center' }),
-      }),
-    ).toBe('bounds')
-    expect(
-      floorplanAnnotationObstacleMode({
-        kind: 'polyline',
-        points: [
-          [0, 0],
-          [1, 0],
-        ],
-        metadata: floorplanGeometryMetadata({ annotationRole: 'stair-annotation' }),
-      }),
-    ).toBe('outline')
-  })
-})
-
 describe('resolveAnnotationLabelRectangles', () => {
   test('keeps the higher-priority label and moves the conflicting label', () => {
     const shifts = resolveAnnotationLabelRectangles([

package/src/components/editor-2d/renderers/floorplan-annotation-layout.ts

@@ -1,6 +1,3 @@
-import type { FloorplanGeometry } from '@pascal-app/core'
-import { readFloorplanGeometryMetadata } from '../../../lib/floorplan/floorplan-extension'
-
 export type AnnotationLabelRectangle = {
   id: string
   x: number
@@ -467,33 +464,6 @@ function candidateCost(
   return preference + distance + perpendicularMovement * 4
 }
 
-export function isFloorplanAnnotationObstacleGeometry(geometry: FloorplanGeometry): boolean {
-  if (floorplanAnnotationObstacleMode(geometry)) return true
-  if (geometry.kind !== 'group') return false
-  const hasPlate = geometry.children.some(
-    (child) => child.kind === 'rect' || child.kind === 'circle',
-  )
-  const hasUprightText = geometry.children.some((child) => child.kind === 'text' && child.upright)
-  return hasPlate && hasUprightText
-}
-
-export function floorplanAnnotationObstacleMode(
-  geometry: FloorplanGeometry,
-): 'bounds' | 'outline' | '' | undefined {
-  const metadata = readFloorplanGeometryMetadata(geometry)
-  if (metadata.annotationObstacle) return metadata.annotationObstacle
-  switch (metadata.annotationRole) {
-    case 'room-label':
-      return geometry.kind === 'text' ? 'bounds' : undefined
-    case 'column-center':
-      return geometry.kind === 'line' || geometry.kind === 'text' ? 'bounds' : undefined
-    case 'stair-annotation':
-      return geometry.kind === 'polyline' || geometry.kind === 'line' ? 'outline' : 'bounds'
-    default:
-      return undefined
-  }
-}
-
 function rectanglesOverlap(
   left: Pick<AnnotationLabelRectangle, 'x' | 'y' | 'width' | 'height'>,
   right: Pick<AnnotationLabelRectangle, 'x' | 'y' | 'width' | 'height'>,

package/src/components/editor-2d/renderers/floorplan-dimension-edit-overlay.tsx

@@ -3,7 +3,8 @@
 import type { AnyNode, AnyNodeId } from '@pascal-app/core'
 import { useLocale, useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
-import { useCallback, useEffect, useRef, useState } from 'react'
+import { FloorplanDimensionHitsProvider } from '@pascal-app/viewer/ui'
+import { type ReactNode, useCallback, useEffect, useRef, useState } from 'react'
 import { createPortal } from 'react-dom'
 import {
   parseDimensionInput,
@@ -26,8 +27,8 @@ import useEditor from '../../../store/use-editor'
  * anchor the value is written as `textOverride` on a construction-dimension
  * node instead, and the label renders an "override" badge.
  *
- * The label is found by DOM delegation on the attributes
- * `floorplan-dimension-renderer.tsx` emits, so this works identically for
+ * The label is found by DOM delegation on the attributes the viewer's
+ * dimension renderer emits under `FloorplanDimensionHitsGate`, so this works identically for
  * `dimension` and `dimension-string` geometry, for automatic wall dimensions,
  * contextual dimensions and manual construction-dimension nodes — and on
  * sheets, which mount the same renderer.
@@ -62,6 +63,15 @@ export function useDimensionEditAllowed(): boolean {
   return useEditor((state) => isDimensionEditAllowed(state, { readOnly }))
 }
 
+/** Plan dimension labels under the editor carry their typeable hit rects while typing is allowed. */
+export function FloorplanDimensionHitsGate({ children }: { children: ReactNode }) {
+  return (
+    <FloorplanDimensionHitsProvider value={useDimensionEditAllowed()}>
+      {children}
+    </FloorplanDimensionHitsProvider>
+  )
+}
+
 /**
  * The typeable dimension value under a press, with the node typing it drives:
  * the pressed element's or, when the plan's dashed group box lies over it, the

package/src/components/editor-2d/renderers/floorplan-draft-measurement.tsx

@@ -19,6 +19,7 @@ export type DraftMeasurement = {
 }
 
 export function FloorplanDraftMeasurement({
+  lengthHidden = false,
   measurement,
   measurementStroke,
   labelBackground,
@@ -26,6 +27,8 @@ export function FloorplanDraftMeasurement({
   sceneRotationDeg,
   unitsPerPixel,
 }: {
+  /** Leave the length plate to something drawn in its place (the typed-entry HUD). */
+  lengthHidden?: boolean
   measurement: DraftMeasurement
   measurementStroke: string
   labelBackground: string
@@ -68,7 +71,10 @@ export function FloorplanDraftMeasurement({
 
   return (
     <g pointerEvents="none">
-      <g transform={`translate(${cx} ${cy}) rotate(${labelAngleDeg})`}>
+      <g
+        display={lengthHidden ? 'none' : undefined}
+        transform={`translate(${cx} ${cy}) rotate(${labelAngleDeg})`}
+      >
         <rect
           fill={labelBg}
           height={lengthPlateH}

package/src/components/editor-2d/renderers/floorplan-placement-preview-layer.tsx

@@ -4,17 +4,18 @@ import {
   type AnyNode,
   type AnyNodeId,
   type FloorplanGeometry,
+  formatLinearMeasurement,
   type GeometryContext,
   nodeRegistry,
   useScene,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
+import { FloorplanDimensionRenderer, FloorplanGeometryRenderer } from '@pascal-app/viewer/ui'
 import { memo, useMemo } from 'react'
-import { formatLinearMeasurement } from '../../../lib/measurements'
 import usePlacementPreview from '../../../store/use-placement-preview'
+import { usePlacementTyping } from '../../../store/use-placement-typing'
 import { useFloorplanRender, useFloorplanSceneRotation } from '../floorplan-render-context'
-import { FloorplanDimensionRenderer } from './floorplan-dimension-renderer'
-import { FloorplanGeometryRenderer } from './floorplan-geometry-renderer'
+import { FloorplanPlacementTypingHud } from './floorplan-placement-typing-hud'
 
 export interface FloorplanNodePreviewProps {
   node: AnyNode
@@ -139,14 +140,24 @@ export const FloorplanPlacementPreviewLayer = memo(function FloorplanPlacementPr
   const dimensions = usePlacementPreview((s) => s.dimensions)
   const activeDimensionId = usePlacementPreview((s) => s.activeDimensionId)
   const dimensionInput = usePlacementPreview((s) => s.dimensionInput)
+  const typingProjectedPosition = usePlacementTyping((s) => s.projectedPosition)
   const unit = useViewer((s) => s.unit)
   const metricNotation = useViewer((s) => s.metricNotation)
   const sceneRotationDeg = useFloorplanSceneRotation()
+  const unitsPerPixel = useFloorplanRender()?.unitsPerPixel ?? 1
   if (!node) return null
 
   return (
     <g data-floorplan-placement-preview>
       <FloorplanNodePreview contextNodes={contextNodes} node={node} parentNode={parentNode} />
+      {typingProjectedPosition ? (
+        <FloorplanPlacementTypingHud
+          sceneRotationDeg={sceneRotationDeg}
+          unitsPerPixel={unitsPerPixel}
+          x={typingProjectedPosition[0]}
+          y={typingProjectedPosition[2]}
+        />
+      ) : null}
       <g data-floorplan-placement-dimensions>
         {dimensions
           .filter((dimension) => dimension.renderInFloorplan !== false)

package/src/components/editor-2d/renderers/floorplan-placement-typing-hud.test.tsx

@@ -0,0 +1,35 @@
+import { afterEach, expect, test } from 'bun:test'
+import {
+  PLACEMENT_TYPING_LENGTH_ANGLE,
+  usePlacementTyping,
+} from '../../../store/use-placement-typing'
+import { renderCurrentMarkup } from '../../../test-utils/render-current-markup'
+import { FloorplanPlacementTypingHud } from './floorplan-placement-typing-hud'
+
+afterEach(() => {
+  usePlacementTyping.getState().clear()
+})
+
+test('sizes and counter-rotates the HUD from the props it is given', () => {
+  usePlacementTyping.getState().begin({ labels: PLACEMENT_TYPING_LENGTH_ANGLE, activeField: 0 })
+
+  const markup = renderCurrentMarkup(
+    <svg>
+      <FloorplanPlacementTypingHud sceneRotationDeg={30} unitsPerPixel={0.02} x={1} y={2} />
+    </svg>,
+  )
+
+  expect(markup).toContain('transform="translate(1 2) rotate(-30)"')
+  expect(markup).toMatch(/<foreignObject[^>]*width="4.72"/)
+  expect(markup).toContain('scale(0.02)')
+})
+
+test('renders nothing without a typing session', () => {
+  const markup = renderCurrentMarkup(
+    <svg>
+      <FloorplanPlacementTypingHud sceneRotationDeg={0} unitsPerPixel={0.02} x={0} y={0} />
+    </svg>,
+  )
+
+  expect(markup).not.toContain('foreignObject')
+})

package/src/components/editor-2d/renderers/floorplan-placement-typing-hud.tsx

@@ -0,0 +1,65 @@
+'use client'
+
+import { usePlacementTyping } from '../../../store/use-placement-typing'
+import { PlacementCoordinateInput } from '../../tools/shared/placement-coordinate-input'
+
+const HUD_WIDTH_PX = 236
+const HUD_HEIGHT_PX = 64
+const HUD_LIFT_PX = 14
+
+/**
+ * The typed-entry HUD placed in the plan at `x`/`y` (level-local metres).
+ * HTML inside a `foreignObject` is laid out in CSS pixels equal to SVG user
+ * units, and the plan's `<g>` is zoomed and rotated, so the box is scaled by
+ * `unitsPerPixel` and counter-rotated to stay screen-sized and upright. Both
+ * come from the caller: the wall draft renders outside `FloorplanRenderProvider`.
+ * It sits just above its anchor, and only the HUD itself takes the pointer, so
+ * clicks on the ghost or the draft under it still land on the plan.
+ */
+export function FloorplanPlacementTypingHud({
+  placeholders,
+  sceneRotationDeg,
+  unitsPerPixel,
+  x,
+  y,
+}: {
+  placeholders?: readonly string[]
+  sceneRotationDeg: number
+  unitsPerPixel: number
+  x: number
+  y: number
+}) {
+  const isActive = usePlacementTyping((state) => state.isActive)
+  const scale = Math.max(unitsPerPixel, 1e-6)
+  if (!isActive) return null
+
+  return (
+    <g transform={`translate(${x} ${y}) rotate(${-sceneRotationDeg})`}>
+      <foreignObject
+        height={HUD_HEIGHT_PX * scale}
+        overflow="visible"
+        pointerEvents="none"
+        style={{ overflow: 'visible' }}
+        width={HUD_WIDTH_PX * scale}
+        x={(-HUD_WIDTH_PX / 2) * scale}
+        y={-(HUD_HEIGHT_PX + HUD_LIFT_PX) * scale}
+      >
+        <div
+          style={{
+            alignItems: 'flex-end',
+            display: 'flex',
+            height: HUD_HEIGHT_PX,
+            justifyContent: 'center',
+            overflow: 'visible',
+            pointerEvents: 'none',
+            transform: `scale(${scale})`,
+            transformOrigin: 'top left',
+            width: HUD_WIDTH_PX,
+          }}
+        >
+          <PlacementCoordinateInput placeholders={placeholders} />
+        </div>
+      </foreignObject>
+    </g>
+  )
+}

package/src/components/editor-2d/renderers/floorplan-registry-layer.test.ts

@@ -7,15 +7,19 @@ import type {
   FloorplanPalette,
   LiveNodeOverrides,
 } from '@pascal-app/core'
-import { type AnyNodeDefinition, emitter, nodeRegistry, registerNode } from '@pascal-app/core'
+import {
+  type AnyNodeDefinition,
+  emitter,
+  floorplanGeometryMetadata,
+  nodeRegistry,
+  registerNode,
+} from '@pascal-app/core'
 import { createElement } from 'react'
 import { renderToStaticMarkup } from 'react-dom/server'
 import { z } from 'zod'
-import {
-  FLOORPLAN_NODE_EXTENSION_KEY,
-  floorplanGeometryMetadata,
-} from '../../../lib/floorplan/floorplan-extension'
+import { AXIS_MOVE_DRAG_LABEL, PATH_POINT_DRAG_LABEL } from '../../../lib/contextual-help'
 import type { SessionWrites } from '../../../lib/session-writes'
+import { snapContextOf } from '../../../lib/snapping-mode'
 import {
   buildFloorplanEntryGeometry,
   cancelFloorplanAffordanceDrag,
@@ -276,6 +280,26 @@ describe('floorplan affordance ownership', () => {
       driver: 'floorplan',
     })
   })
+
+  // With no scope, Select mode reads every snap mode as off, so these drags
+  // never snapped to the grid on the plan.
+  test('gives the MEP run point and segment drags a handle-drag scope in the run snap context', () => {
+    const point = floorplanAffordanceReshapeScope('move-path-point', 'duct_1', { pointIndex: 0 })
+    const segment = floorplanAffordanceReshapeScope('move-segment', 'duct_1', { segmentIndex: 0 })
+    expect(point).toEqual({ kind: 'handle-drag', nodeId: 'duct_1', handle: PATH_POINT_DRAG_LABEL })
+    expect(segment).toEqual({ kind: 'handle-drag', nodeId: 'duct_1', handle: AXIS_MOVE_DRAG_LABEL })
+    for (const scope of [point, segment]) {
+      expect(
+        snapContextOf({
+          scope: scope!,
+          mode: 'select',
+          tool: null,
+          profileOf: () => undefined,
+          profileOfNode: () => 'structural',
+        }),
+      ).toBe('polygon')
+    }
+  })
 })
 
 function cabinetRun(id: string, children: string[] = [], parentId: string | null = 'level_test') {
@@ -754,11 +778,7 @@ describe('collectFloorplanLinkedLevelNodes', () => {
       category: 'structure',
       defaults: () => ({}) as never,
       floorplan: () => null,
-      extensions: {
-        [FLOORPLAN_NODE_EXTENSION_KEY]: {
-          linkedLevelIds: () => ['level_upper' as AnyNodeId],
-        },
-      },
+      floorplanLinkedLevelIds: () => ['level_upper' as AnyNodeId],
     } as unknown as AnyNodeDefinition)
     const child = {
       id: 'linked_child',

package/src/components/editor-2d/renderers/floorplan-registry-layer.tsx

@@ -4,15 +4,22 @@ import {
   type AnyNode,
   type AnyNodeDefinition,
   type AnyNodeId,
+  buildFloorplanContext,
+  createFloorplanContextExtensions,
   createSceneApi,
   emitter,
   type FloorplanAffordanceSession,
+  type FloorplanAnnotationRole,
   type FloorplanGeometry,
   type FloorplanPalette,
   type FloorplanPoint,
   type FloorplanScope,
+  type FloorplanWallDimensionFaces,
+  floorplanAnnotationObstacleMode,
+  floorplanLayerRank,
   type GeometryContext,
   hidesDescendants,
+  isFloorplanAnnotationObstacleGeometry,
   isNodeKindEnabled,
   isRegistryMovable,
   kindsWithFloorplanScope,
@@ -20,6 +27,7 @@ import {
   type LiveTransform,
   nodeRegistry,
   pauseSceneHistory,
+  readFloorplanGeometryMetadata,
   resolveBuildingForLevel,
   resolveSelectionProxyId,
   resumeSceneHistory,
@@ -28,6 +36,10 @@ import {
   useLiveNodeOverrides,
   useLiveTransforms,
   useScene,
+  WALL_PULL_AFFORDANCE,
+  WALL_PUSH_AFFORDANCE,
+  type WallPullGripPayload,
+  withFloorplanGeometryMetadata,
 } from '@pascal-app/core'
 import {
   beginPerfAction,
@@ -37,6 +49,14 @@ import {
   useRevealWaiting,
   useViewer,
 } from '@pascal-app/viewer'
+import {
+  FloorplanDimensionRenderer,
+  FloorplanGeometryRenderer,
+  resolveFloorplanAnnotationUpdate,
+  resolveFloorplanLabelAngle,
+  selectionModifiersFromEvent,
+  updateSvgFloorplanLabelOrientations,
+} from '@pascal-app/viewer/ui'
 import {
   type ComponentProps,
   memo,
@@ -55,11 +75,14 @@ import {
   hoverRoomFromHit,
   resolvePlanRoomHit,
   roomPickingEnabled,
-  selectionModifiersFromEvent,
   useRoomRecords,
 } from '../../../hooks/use-selected-room'
 import { useCeilingEditSession } from '../../../lib/ceiling-edit-session'
-import { ROTATE_HANDLE_DRAG_LABEL } from '../../../lib/contextual-help'
+import {
+  AXIS_MOVE_DRAG_LABEL,
+  PATH_POINT_DRAG_LABEL,
+  ROTATE_HANDLE_DRAG_LABEL,
+} from '../../../lib/contextual-help'
 import {
   canDirectRotateNode,
   resolveDirectManipulationNode,
@@ -75,22 +98,11 @@ import {
   filterFloorplanAnnotationGeometry,
 } from '../../../lib/floorplan/annotation-visibility'
 import { resolveNodeForDrawingType } from '../../../lib/floorplan/drawing-coordination'
-import {
-  createFloorplanContextExtensions,
-  type FloorplanAnnotationRole,
-  type FloorplanWallDimensionFaces,
-  getFloorplanNodeExtension,
-  readFloorplanGeometryMetadata,
-  withFloorplanGeometryMetadata,
-} from '../../../lib/floorplan/floorplan-extension'
+import { getFloorplanNodeExtension } from '../../../lib/floorplan/floorplan-extension'
 import {
   type FloorplanMode,
   resolveFloorplanAnnotationVisibility,
 } from '../../../lib/floorplan/floorplan-mode'
-import {
-  buildFloorplanContext,
-  floorplanLayerRank,
-} from '../../../lib/floorplan/floorplan-readonly'
 import { clientToPlan } from '../../../lib/floorplan/plan-coords'
 import {
   type ActiveInteractionScope,
@@ -102,7 +114,7 @@ import {
   isIdle,
   tangentReshapeScope,
 } from '../../../lib/interaction/scope'
-import { runFloorplanWallPush, WALL_PUSH_AFFORDANCE } from '../../../lib/room-handle-drag'
+import { runFloorplanWallPush } from '../../../lib/room-handle-drag'
 import { selectRoom, selectRoomFromHit } from '../../../lib/room-selection-commands'
 import { clickZoneArea, hoverZoneArea } from '../../../lib/room-zone-routing'
 import {
@@ -114,11 +126,7 @@ import { createSessionWrites, type SessionWrites } from '../../../lib/session-wr
 import { sfxEmitter } from '../../../lib/sfx-bus'
 import { clearSurfacePlanSnapFeedback } from '../../../lib/surface-plan-snap'
 import { paintZoneMembership } from '../../../lib/units'
-import {
-  startWallPull,
-  WALL_PULL_AFFORDANCE,
-  type WallPullGripPayload,
-} from '../../../lib/wall-pull'
+import { startWallPull } from '../../../lib/wall-pull'
 import useDirectManipulationFeedback from '../../../store/use-direct-manipulation-feedback'
 import useDrawingView from '../../../store/use-drawing-view'
 import useEditor, { isAngleSnapActive, type Mode } from '../../../store/use-editor'
@@ -153,23 +161,11 @@ import {
   useFloorplanStaticRender,
   useFloorplanStaticUnitsPerPixel,
 } from '../floorplan-render-context'
-import {
-  floorplanAnnotationObstacleMode,
-  isFloorplanAnnotationObstacleGeometry,
-  resolveSvgAnnotationCollisions,
-  svgAnnotationLabelId,
-} from './floorplan-annotation-layout'
+import { resolveSvgAnnotationCollisions, svgAnnotationLabelId } from './floorplan-annotation-layout'
 import {
   FloorplanDimensionEditOverlay,
   typeableDimensionAt,
 } from './floorplan-dimension-edit-overlay'
-import { FloorplanDimensionRenderer } from './floorplan-dimension-renderer'
-import { FloorplanGeometryRenderer } from './floorplan-geometry-renderer'
-import {
-  resolveFloorplanAnnotationUpdate,
-  resolveFloorplanLabelAngle,
-  updateSvgFloorplanLabelOrientations,
-} from './floorplan-label-angle'
 import { useFloorplanReveal } from './floorplan-reveal'
 
 /**
@@ -321,7 +317,7 @@ export function subscribeFloorplanAffordanceToolCancel(
 // edits that set a direction/shape map to a scope; resize / rotate / body-move
 // affordances return `null` (no polygon/wall snapping chip). Keyed off the
 // affordance name the kinds register (`move-vertex` / `move-edge` / `add-vertex`
-// / `curve` / `move-endpoint`).
+// / `curve` / `move-endpoint` / `move-path-point` / `move-segment`).
 export function floorplanAffordanceReshapeScope(
   affordance: string,
   nodeId: string,
@@ -362,6 +358,14 @@ export function floorplanAffordanceReshapeScope(
   if (affordance.includes('rotate')) {
     return { kind: 'handle-drag', nodeId, handle: ROTATE_HANDLE_DRAG_LABEL }
   }
+  // MEP run point and run segment drags: the same handle-drag scopes as their
+  // 3D arrows, so they snap in the kind's own context (polygon for runs).
+  if (affordance === 'move-path-point') {
+    return { kind: 'handle-drag', nodeId, handle: PATH_POINT_DRAG_LABEL }
+  }
+  if (affordance === 'move-segment') {
+    return { kind: 'handle-drag', nodeId, handle: AXIS_MOVE_DRAG_LABEL }
+  }
   return null
 }
 
@@ -3633,7 +3637,7 @@ export function collectFloorplanLinkedLevelNodes(
   for (const [rawId, node] of Object.entries(nodes)) {
     if (!node) continue
     const definition = nodeRegistry.get(node.type)
-    const linkedLevelIds = getFloorplanNodeExtension(definition)?.linkedLevelIds
+    const linkedLevelIds = definition?.floorplanLinkedLevelIds
     if (!definition?.floorplan || !linkedLevelIds) continue
     const id = rawId as AnyNodeId
     if (excludedIds.has(id)) continue