feat: sync surface polygon editing

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

@@ -19,7 +19,6 @@ import {
   useLiveTransforms,
   useScene,
 } from '@pascal-app/core'
-import { useAlignmentGuides } from '@pascal-app/editor'
 import { useViewer } from '@pascal-app/viewer'
 import {
   memo,
@@ -31,6 +30,7 @@ import {
   useState,
 } from 'react'
 import { sfxEmitter } from '../../../lib/sfx-bus'
+import { clearSurfacePlanSnapFeedback } from '../../../lib/surface-plan-snap'
 import useEditor from '../../../store/use-editor'
 import { useFloorplanRender } from '../floorplan-render-context'
 import { FloorplanGeometryRenderer } from './floorplan-geometry-renderer'
@@ -603,6 +603,7 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
         }
         drag.session.commit()
         sfxEmitter.emit('sfx:structure-build')
+        clearSurfacePlanSnapFeedback()
         dragRef.current = null
         setActiveDragId(null)
         setRotationOverlay(null)
@@ -654,6 +655,7 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
         for (const id of drag.session.affectedIds) overrides.clear(id)
       }
 
+      clearSurfacePlanSnapFeedback()
       dragRef.current = null
       setActiveDragId(null)
       setRotationOverlay(null)
@@ -672,7 +674,7 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
       // Affordances that publish Figma alignment guides during `apply`
       // (fence endpoint) leave them in the store on cancel — `canCommit`
       // (the pointer-up clear) never runs on a cancel.
-      useAlignmentGuides.getState().clear()
+      clearSurfacePlanSnapFeedback()
       // Drop any live overrides the session may have published. No-op
       // for affordances whose `apply()` writes straight to scene; the
       // override-routed sessions (wall endpoint, wall curve) rely on
@@ -707,7 +709,7 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
         dragRef.current = null
       }
       // Clear any alignment guide a session left behind on mid-drag unmount.
-      useAlignmentGuides.getState().clear()
+      clearSurfacePlanSnapFeedback()
     }
   }, [])
 

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

@@ -77,6 +77,7 @@ import {
 import { guideEmitter } from '../../lib/guide-events'
 import { sfxEmitter } from '../../lib/sfx-bus'
 import { SITE_BOUNDARY_DRAG_LABEL } from '../../lib/site-boundary'
+import { resolveSlabPlanPointSnap } from '../../lib/slab-plan-snap'
 import { cn } from '../../lib/utils'
 import { snapBuildingLocalToWorldGrid } from '../../lib/world-grid-snap'
 import type { GuideUiState, NavigationSyncPose } from '../../store/use-editor'
@@ -8507,13 +8508,25 @@ export function FloorplanPanel() {
       // moves (the catch-all would otherwise swallow the move event).
       if (isPolygonBuildActive) {
         const angleSnap = activePolygonDraftPoints.length > 0 && !shiftPressed
-        let snappedPoint = snapPolygonDraftPoint({
+        const fallbackPoint = snapPolygonDraftPoint({
           point: planPoint,
           start: activePolygonDraftPoints[activePolygonDraftPoints.length - 1],
           angleSnap,
         })
-        if (angleSnap) useAlignmentGuides.getState().clear()
-        else snappedPoint = alignFloorplanDraftPoint(snappedPoint, { bypass: event.altKey })
+        let snappedPoint = fallbackPoint
+        if (isSlabBuildActive) {
+          snappedPoint = resolveSlabPlanPointSnap({
+            rawPoint: planPoint,
+            fallbackPoint,
+            levelId,
+            altKey: event.altKey,
+            align: !angleSnap,
+          }).point
+        } else if (angleSnap) {
+          useAlignmentGuides.getState().clear()
+        } else {
+          snappedPoint = alignFloorplanDraftPoint(fallbackPoint, { bypass: event.altKey })
+        }
 
         // Emit `grid:move` so the registry-driven slab tool also tracks
         // the cursor (its 3D preview needs it).
@@ -8681,6 +8694,7 @@ export function FloorplanPanel() {
       isOpeningPlacementActive,
       isPolygonBuildActive,
       isRoofBuildActive,
+      isSlabBuildActive,
       isWallBuildActive,
       levelId,
       publishFloorplanNavigationPose,
@@ -8939,6 +8953,7 @@ export function FloorplanPanel() {
     isOpeningPlacementActive,
     isPolygonBuildActive,
     isRoofBuildActive,
+    isSlabBuildActive,
     isWallBuildActive,
     isZoneBuildActive,
     levelId,
@@ -9141,10 +9156,17 @@ export function FloorplanPanel() {
       if (isZoneBuildActive) {
         handleZonePlacementConfirm(fallbackPoint)
       } else {
+        const snappedPoint = resolveSlabPlanPointSnap({
+          rawPoint: planPoint,
+          fallbackPoint,
+          levelId,
+          altKey: event.altKey,
+          align: !angleSnap,
+        }).point
         // Slab is registry-driven: forward the double-click so the 3D tool
         // commits the node (zone has no registry tool, so it commits locally).
-        emitFloorplanGridEvent('double-click', planPoint, event)
-        handleSlabPlacementConfirm(fallbackPoint)
+        emitFloorplanGridEvent('double-click', snappedPoint, event)
+        handleSlabPlacementConfirm(snappedPoint)
       }
     },
     [

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

@@ -4,6 +4,7 @@ import { emitter, type FenceNode, isCurvedWall, type WallNode } from '@pascal-ap
 import { type MouseEvent as ReactMouseEvent, useCallback } from 'react'
 import { resolveCeilingPlanPointSnap } from '../../lib/ceiling-plan-snap'
 import { alignFloorplanDraftPoint, getPlanPointDistance } from '../../lib/floorplan'
+import { resolveSlabPlanPointSnap } from '../../lib/slab-plan-snap'
 import { snapFenceDraftPoint } from '../tools/fence/fence-drafting'
 import {
   WALL_FINE_GRID_STEP,
@@ -50,6 +51,7 @@ type UseFloorplanBackgroundPlacementArgs = {
   isOpeningPlacementActive: boolean
   isPolygonBuildActive: boolean
   isRoofBuildActive: boolean
+  isSlabBuildActive: boolean
   isWallBuildActive: boolean
   isZoneBuildActive: boolean
   levelId: string | null
@@ -107,6 +109,7 @@ export function useFloorplanBackgroundPlacement({
   isOpeningPlacementActive,
   isPolygonBuildActive,
   isRoofBuildActive,
+  isSlabBuildActive,
   isWallBuildActive,
   isZoneBuildActive,
   levelId,
@@ -233,13 +236,22 @@ export function useFloorplanBackgroundPlacement({
       // the 2D draft polygon invisible while the 3D tool builds fine).
       if (isPolygonBuildActive) {
         const angleSnap = activePolygonDraftPoints.length > 0 && !shiftPressed
-        let snappedPoint = snapPolygonDraftPoint({
+        const fallbackPoint = snapPolygonDraftPoint({
           point: planPoint,
           start: activePolygonDraftPoints[activePolygonDraftPoints.length - 1],
           angleSnap,
         })
-        if (!angleSnap) {
-          snappedPoint = alignFloorplanDraftPoint(snappedPoint, { bypass: event.altKey })
+        let snappedPoint = fallbackPoint
+        if (isSlabBuildActive) {
+          snappedPoint = resolveSlabPlanPointSnap({
+            rawPoint: planPoint,
+            fallbackPoint,
+            levelId,
+            altKey: event.altKey,
+            align: !angleSnap,
+          }).point
+        } else if (!angleSnap) {
+          snappedPoint = alignFloorplanDraftPoint(fallbackPoint, { bypass: event.altKey })
         }
 
         // Emit the grid event so the registry-driven slab tool also
@@ -328,6 +340,7 @@ export function useFloorplanBackgroundPlacement({
       isOpeningPlacementActive,
       isPolygonBuildActive,
       isRoofBuildActive,
+      isSlabBuildActive,
       isWallBuildActive,
       isZoneBuildActive,
       levelId,

packages/editor/src/index.tsx

@@ -234,6 +234,13 @@ export { clearRoofDuplicateMetadata, duplicateRoofSubtree } from './lib/roof-dup
 export type { SceneGraph } from './lib/scene'
 export { applySceneGraphToEditor } from './lib/scene'
 export { triggerSFX } from './lib/sfx-bus'
+export {
+  clearSlabSnapFeedback,
+  resolveSlabPlanPointSnap,
+  SLAB_ALIGNMENT_THRESHOLD_M,
+  type SlabPlanSnapInput,
+  type SlabPlanSnapResult,
+} from './lib/slab-plan-snap'
 export { duplicateStairSubtree } from './lib/stair-duplication'
 export {
   getBuildingLevelsForLevel,
@@ -243,6 +250,13 @@ export {
   resolveStairPlacementLevelId,
   resolveStairToLevelId,
 } from './lib/stair-levels'
+export {
+  clearSurfacePlanSnapFeedback,
+  resolveSurfacePlanPointSnap,
+  SURFACE_ALIGNMENT_THRESHOLD_M,
+  type SurfacePlanSnapInput,
+  type SurfacePlanSnapResult,
+} from './lib/surface-plan-snap'
 // `cn` (twMerge + clsx) — used by kind-owned panels in `@pascal-app/
 // nodes` so they don't need their own copy / their own tailwind-merge
 // dependency.

packages/editor/src/lib/ceiling-plan-snap.ts

@@ -1,232 +1,24 @@
 import {
-  type AlignmentAnchor,
-  type AlignmentGuide,
-  type AnyNode,
-  collectAlignmentAnchors,
-  getWallCurveFrameAt,
-  getWallCurveLength,
-  isCurvedWall,
-  resolveAlignment,
-  resolveLevelId,
-  useScene,
-  type WallNode,
-} from '@pascal-app/core'
-import {
-  getSegmentGridStep,
-  snapWallDraftPointDetailed,
-  type WallDraftSnapKind,
-  type WallPlanPoint,
-  type WallSnapRadii,
-} from '../components/tools/wall/wall-drafting'
-import useAlignmentGuides from '../store/use-alignment-guides'
-import useEditor from '../store/use-editor'
-import useWallSnapIndicator from '../store/use-wall-snap-indicator'
+  clearSurfacePlanSnapFeedback,
+  resolveSurfacePlanPointSnap,
+  SURFACE_ALIGNMENT_THRESHOLD_M,
+  type SurfacePlanSnapInput,
+  type SurfacePlanSnapResult,
+} from './surface-plan-snap'
 
 const CEILING_SNAP_MOVING_ID = '__ceiling_snap__'
-export const CEILING_ALIGNMENT_THRESHOLD_M = 0.08
-const CEILING_WALL_SNAP_RADII = {
-  endpoint: 0.38,
-  midpoint: 0.28,
-  intersection: 0.28,
-  wall: 0.18,
-} satisfies WallSnapRadii
-const WALL_SOURCE_MATCH_EPSILON = 0.035
 
-export type CeilingPlanSnapInput = {
-  rawPoint: WallPlanPoint
-  fallbackPoint?: WallPlanPoint
-  levelId?: string | null
-  excludeId?: string | null
-  movingId?: string
-  nodes?: Readonly<Record<string, AnyNode>>
-  walls?: readonly WallNode[]
-  candidates?: readonly AlignmentAnchor[]
-  threshold?: number
-  altKey?: boolean
-  magnetic?: boolean
-  align?: boolean
-  step?: number
-  snapRadii?: WallSnapRadii
-}
-
-export type CeilingPlanSnapResult = {
-  point: WallPlanPoint
-  wallSnap: WallDraftSnapKind | null
-  guides: AlignmentGuide[]
-  wallIds: string[]
-}
-
-function getLevelWalls(
-  nodes: Readonly<Record<string, AnyNode>>,
-  levelId: string | null | undefined,
-  walls?: readonly WallNode[],
-): WallNode[] {
-  const source =
-    walls ?? Object.values(nodes).filter((node): node is WallNode => node.type === 'wall')
-  if (!levelId) return source.filter((wall) => wall.visible !== false)
-
-  return source.filter(
-    (wall) =>
-      wall.visible !== false && resolveLevelId(wall, nodes as Record<string, AnyNode>) === levelId,
-  )
-}
-
-function distanceSquared(a: WallPlanPoint, b: WallPlanPoint) {
-  const dx = a[0] - b[0]
-  const dz = a[1] - b[1]
-  return dx * dx + dz * dz
-}
-
-function wallMidpoint(wall: WallNode): WallPlanPoint {
-  if (isCurvedWall(wall)) {
-    const frame = getWallCurveFrameAt(wall, 0.5)
-    return [frame.point.x, frame.point.y]
-  }
-  return [(wall.start[0] + wall.end[0]) / 2, (wall.start[1] + wall.end[1]) / 2]
-}
-
-function distanceToSegmentSquared(point: WallPlanPoint, start: WallPlanPoint, end: WallPlanPoint) {
-  const dx = end[0] - start[0]
-  const dz = end[1] - start[1]
-  const lengthSquared = dx * dx + dz * dz
-  if (lengthSquared < 1e-9) return distanceSquared(point, start)
-
-  const t = Math.max(
-    0,
-    Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / lengthSquared),
-  )
-  const projected: WallPlanPoint = [start[0] + dx * t, start[1] + dz * t]
-  return distanceSquared(point, projected)
-}
-
-function distanceToWallSquared(point: WallPlanPoint, wall: WallNode) {
-  if (!isCurvedWall(wall)) {
-    return distanceToSegmentSquared(point, wall.start, wall.end)
-  }
-
-  const sampleCount = Math.max(8, Math.ceil(getWallCurveLength(wall) / 0.3))
-  let bestDistanceSquared = Number.POSITIVE_INFINITY
-  let previous = getWallCurveFrameAt(wall, 0).point
-  for (let index = 1; index <= sampleCount; index += 1) {
-    const current = getWallCurveFrameAt(wall, index / sampleCount).point
-    const distance = distanceToSegmentSquared(
-      point,
-      [previous.x, previous.y],
-      [current.x, current.y],
-    )
-    bestDistanceSquared = Math.min(bestDistanceSquared, distance)
-    previous = current
-  }
-  return bestDistanceSquared
-}
-
-function closestWallIds(point: WallPlanPoint, walls: readonly WallNode[], count: number) {
-  return walls
-    .map((wall) => ({ id: wall.id, distance: distanceToWallSquared(point, wall) }))
-    .sort((a, b) => a.distance - b.distance)
-    .slice(0, count)
-    .map(({ id }) => id)
-}
-
-function findSnapSourceWallIds(
-  point: WallPlanPoint,
-  kind: WallDraftSnapKind,
-  walls: readonly WallNode[],
-): string[] {
-  const epsilonSquared = WALL_SOURCE_MATCH_EPSILON ** 2
-
-  if (kind === 'endpoint') {
-    const endpointMatches = walls.filter(
-      (wall) =>
-        distanceSquared(point, wall.start) <= epsilonSquared ||
-        distanceSquared(point, wall.end) <= epsilonSquared,
-    )
-    if (endpointMatches.length > 0) return endpointMatches.map((wall) => wall.id)
-    return closestWallIds(point, walls, 1)
-  }
-
-  if (kind === 'midpoint') {
-    const midpointMatches = walls.filter(
-      (wall) => distanceSquared(point, wallMidpoint(wall)) <= epsilonSquared,
-    )
-    if (midpointMatches.length > 0) return midpointMatches.map((wall) => wall.id)
-    return closestWallIds(point, walls, 1)
-  }
-
-  if (kind === 'intersection') {
-    const crossingMatches = walls.filter(
-      (wall) => distanceToWallSquared(point, wall) <= epsilonSquared,
-    )
-    if (crossingMatches.length > 0) return crossingMatches.map((wall) => wall.id).slice(0, 2)
-    return closestWallIds(point, walls, 2)
-  }
-
-  return closestWallIds(point, walls, 1)
-}
+export const CEILING_ALIGNMENT_THRESHOLD_M = SURFACE_ALIGNMENT_THRESHOLD_M
+export type CeilingPlanSnapInput = SurfacePlanSnapInput
+export type CeilingPlanSnapResult = SurfacePlanSnapResult
 
 export function clearCeilingSnapFeedback() {
-  useAlignmentGuides.getState().clear()
-  useWallSnapIndicator.getState().clear()
+  clearSurfacePlanSnapFeedback()
 }
 
 export function resolveCeilingPlanPointSnap(input: CeilingPlanSnapInput): CeilingPlanSnapResult {
-  const nodes = input.nodes ?? useScene.getState().nodes
-  const walls = getLevelWalls(nodes, input.levelId, input.walls)
-  const fallbackPoint = input.fallbackPoint
-  const magnetic = input.magnetic ?? useEditor.getState().magneticSnap
-
-  const wallSnap = snapWallDraftPointDetailed({
-    point: input.rawPoint,
-    walls,
-    step: input.step ?? getSegmentGridStep(),
-    magnetic,
-    snapRadii: input.snapRadii ?? CEILING_WALL_SNAP_RADII,
-    gridSnap: fallbackPoint ? () => fallbackPoint : undefined,
+  return resolveSurfacePlanPointSnap({
+    ...input,
+    movingId: input.movingId ?? CEILING_SNAP_MOVING_ID,
   })
-
-  if (wallSnap.snap) {
-    const wallIds = findSnapSourceWallIds(wallSnap.point, wallSnap.snap, walls)
-    useWallSnapIndicator
-      .getState()
-      .set({ x: wallSnap.point[0], z: wallSnap.point[1], kind: wallSnap.snap, wallIds })
-    useAlignmentGuides.getState().clear()
-    return { point: wallSnap.point, wallSnap: wallSnap.snap, guides: [], wallIds }
-  }
-
-  useWallSnapIndicator.getState().clear()
-
-  const basePoint = fallbackPoint ?? wallSnap.point
-  if (input.align === false || input.altKey) {
-    useAlignmentGuides.getState().clear()
-    return { point: basePoint, wallSnap: null, guides: [], wallIds: [] }
-  }
-
-  const movingId = input.movingId ?? CEILING_SNAP_MOVING_ID
-  const candidates =
-    input.candidates ??
-    collectAlignmentAnchors(nodes, input.excludeId ?? movingId, input.levelId ?? null)
-
-  if (candidates.length === 0) {
-    useAlignmentGuides.getState().clear()
-    return { point: basePoint, wallSnap: null, guides: [], wallIds: [] }
-  }
-
-  const alignment = resolveAlignment({
-    moving: [{ nodeId: movingId, kind: 'corner', x: basePoint[0], z: basePoint[1] }],
-    candidates,
-    threshold: input.threshold ?? CEILING_ALIGNMENT_THRESHOLD_M,
-  })
-
-  useAlignmentGuides.getState().set(alignment.guides)
-
-  if (!alignment.snap) {
-    return { point: basePoint, wallSnap: null, guides: alignment.guides, wallIds: [] }
-  }
-
-  return {
-    point: [basePoint[0] + alignment.snap.dx, basePoint[1] + alignment.snap.dz],
-    wallSnap: null,
-    guides: alignment.guides,
-    wallIds: [],
-  }
 }

packages/editor/src/lib/slab-plan-snap.ts

@@ -0,0 +1,25 @@
+import {
+  clearSurfacePlanSnapFeedback,
+  resolveSurfacePlanPointSnap,
+  SURFACE_ALIGNMENT_THRESHOLD_M,
+  type SurfacePlanSnapInput,
+  type SurfacePlanSnapResult,
+} from './surface-plan-snap'
+
+const SLAB_SNAP_MOVING_ID = '__slab_snap__'
+
+export const SLAB_ALIGNMENT_THRESHOLD_M = SURFACE_ALIGNMENT_THRESHOLD_M
+export type SlabPlanSnapInput = SurfacePlanSnapInput
+export type SlabPlanSnapResult = SurfacePlanSnapResult
+
+export function clearSlabSnapFeedback() {
+  clearSurfacePlanSnapFeedback()
+}
+
+export function resolveSlabPlanPointSnap(input: SlabPlanSnapInput): SlabPlanSnapResult {
+  return resolveSurfacePlanPointSnap({
+    ...input,
+    highlightWalls: input.highlightWalls ?? false,
+    movingId: input.movingId ?? SLAB_SNAP_MOVING_ID,
+  })
+}

packages/editor/src/lib/surface-plan-snap.ts

@@ -0,0 +1,239 @@
+import {
+  type AlignmentAnchor,
+  type AlignmentGuide,
+  type AnyNode,
+  collectAlignmentAnchors,
+  getWallCurveFrameAt,
+  getWallCurveLength,
+  isCurvedWall,
+  resolveAlignment,
+  resolveLevelId,
+  useScene,
+  type WallNode,
+} from '@pascal-app/core'
+import {
+  getSegmentGridStep,
+  snapWallDraftPointDetailed,
+  type WallDraftSnapKind,
+  type WallPlanPoint,
+  type WallSnapRadii,
+} from '../components/tools/wall/wall-drafting'
+import useAlignmentGuides from '../store/use-alignment-guides'
+import useEditor from '../store/use-editor'
+import useWallSnapIndicator from '../store/use-wall-snap-indicator'
+
+const SURFACE_SNAP_MOVING_ID = '__surface_snap__'
+export const SURFACE_ALIGNMENT_THRESHOLD_M = 0.08
+const SURFACE_WALL_SNAP_RADII = {
+  endpoint: 0.38,
+  midpoint: 0.28,
+  intersection: 0.28,
+  wall: 0.18,
+} satisfies WallSnapRadii
+const WALL_SOURCE_MATCH_EPSILON = 0.035
+
+export type SurfacePlanSnapInput = {
+  rawPoint: WallPlanPoint
+  fallbackPoint?: WallPlanPoint
+  levelId?: string | null
+  excludeId?: string | null
+  movingId?: string
+  nodes?: Readonly<Record<string, AnyNode>>
+  walls?: readonly WallNode[]
+  candidates?: readonly AlignmentAnchor[]
+  threshold?: number
+  altKey?: boolean
+  magnetic?: boolean
+  align?: boolean
+  highlightWalls?: boolean
+  step?: number
+  snapRadii?: WallSnapRadii
+}
+
+export type SurfacePlanSnapResult = {
+  point: WallPlanPoint
+  wallSnap: WallDraftSnapKind | null
+  guides: AlignmentGuide[]
+  wallIds: string[]
+}
+
+function getLevelWalls(
+  nodes: Readonly<Record<string, AnyNode>>,
+  levelId: string | null | undefined,
+  walls?: readonly WallNode[],
+): WallNode[] {
+  const source =
+    walls ?? Object.values(nodes).filter((node): node is WallNode => node.type === 'wall')
+  if (!levelId) return source.filter((wall) => wall.visible !== false)
+
+  return source.filter(
+    (wall) =>
+      wall.visible !== false && resolveLevelId(wall, nodes as Record<string, AnyNode>) === levelId,
+  )
+}
+
+function distanceSquared(a: WallPlanPoint, b: WallPlanPoint) {
+  const dx = a[0] - b[0]
+  const dz = a[1] - b[1]
+  return dx * dx + dz * dz
+}
+
+function wallMidpoint(wall: WallNode): WallPlanPoint {
+  if (isCurvedWall(wall)) {
+    const frame = getWallCurveFrameAt(wall, 0.5)
+    return [frame.point.x, frame.point.y]
+  }
+  return [(wall.start[0] + wall.end[0]) / 2, (wall.start[1] + wall.end[1]) / 2]
+}
+
+function distanceToSegmentSquared(point: WallPlanPoint, start: WallPlanPoint, end: WallPlanPoint) {
+  const dx = end[0] - start[0]
+  const dz = end[1] - start[1]
+  const lengthSquared = dx * dx + dz * dz
+  if (lengthSquared < 1e-9) return distanceSquared(point, start)
+
+  const t = Math.max(
+    0,
+    Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / lengthSquared),
+  )
+  const projected: WallPlanPoint = [start[0] + dx * t, start[1] + dz * t]
+  return distanceSquared(point, projected)
+}
+
+function distanceToWallSquared(point: WallPlanPoint, wall: WallNode) {
+  if (!isCurvedWall(wall)) {
+    return distanceToSegmentSquared(point, wall.start, wall.end)
+  }
+
+  const sampleCount = Math.max(8, Math.ceil(getWallCurveLength(wall) / 0.3))
+  let bestDistanceSquared = Number.POSITIVE_INFINITY
+  let previous = getWallCurveFrameAt(wall, 0).point
+  for (let index = 1; index <= sampleCount; index += 1) {
+    const current = getWallCurveFrameAt(wall, index / sampleCount).point
+    const distance = distanceToSegmentSquared(
+      point,
+      [previous.x, previous.y],
+      [current.x, current.y],
+    )
+    bestDistanceSquared = Math.min(bestDistanceSquared, distance)
+    previous = current
+  }
+  return bestDistanceSquared
+}
+
+function closestWallIds(point: WallPlanPoint, walls: readonly WallNode[], count: number) {
+  return walls
+    .map((wall) => ({ id: wall.id, distance: distanceToWallSquared(point, wall) }))
+    .sort((a, b) => a.distance - b.distance)
+    .slice(0, count)
+    .map(({ id }) => id)
+}
+
+function findSnapSourceWallIds(
+  point: WallPlanPoint,
+  kind: WallDraftSnapKind,
+  walls: readonly WallNode[],
+): string[] {
+  const epsilonSquared = WALL_SOURCE_MATCH_EPSILON ** 2
+
+  if (kind === 'endpoint') {
+    const endpointMatches = walls.filter(
+      (wall) =>
+        distanceSquared(point, wall.start) <= epsilonSquared ||
+        distanceSquared(point, wall.end) <= epsilonSquared,
+    )
+    if (endpointMatches.length > 0) return endpointMatches.map((wall) => wall.id)
+    return closestWallIds(point, walls, 1)
+  }
+
+  if (kind === 'midpoint') {
+    const midpointMatches = walls.filter(
+      (wall) => distanceSquared(point, wallMidpoint(wall)) <= epsilonSquared,
+    )
+    if (midpointMatches.length > 0) return midpointMatches.map((wall) => wall.id)
+    return closestWallIds(point, walls, 1)
+  }
+
+  if (kind === 'intersection') {
+    const crossingMatches = walls.filter(
+      (wall) => distanceToWallSquared(point, wall) <= epsilonSquared,
+    )
+    if (crossingMatches.length > 0) return crossingMatches.map((wall) => wall.id).slice(0, 2)
+    return closestWallIds(point, walls, 2)
+  }
+
+  return closestWallIds(point, walls, 1)
+}
+
+export function clearSurfacePlanSnapFeedback() {
+  useAlignmentGuides.getState().clear()
+  useWallSnapIndicator.getState().clear()
+}
+
+export function resolveSurfacePlanPointSnap(input: SurfacePlanSnapInput): SurfacePlanSnapResult {
+  const nodes = input.nodes ?? useScene.getState().nodes
+  const walls = getLevelWalls(nodes, input.levelId, input.walls)
+  const fallbackPoint = input.fallbackPoint
+  const magnetic = input.magnetic ?? useEditor.getState().magneticSnap
+
+  const wallSnap = snapWallDraftPointDetailed({
+    point: input.rawPoint,
+    walls,
+    step: input.step ?? getSegmentGridStep(),
+    magnetic,
+    snapRadii: input.snapRadii ?? SURFACE_WALL_SNAP_RADII,
+    gridSnap: fallbackPoint ? () => fallbackPoint : undefined,
+  })
+
+  if (wallSnap.snap) {
+    const wallIds =
+      input.highlightWalls === false
+        ? []
+        : findSnapSourceWallIds(wallSnap.point, wallSnap.snap, walls)
+    useWallSnapIndicator.getState().set({
+      x: wallSnap.point[0],
+      z: wallSnap.point[1],
+      kind: wallSnap.snap,
+      ...(wallIds.length > 0 ? { wallIds } : {}),
+    })
+    useAlignmentGuides.getState().clear()
+    return { point: wallSnap.point, wallSnap: wallSnap.snap, guides: [], wallIds }
+  }
+
+  useWallSnapIndicator.getState().clear()
+
+  const basePoint = fallbackPoint ?? wallSnap.point
+  if (input.align === false || input.altKey) {
+    useAlignmentGuides.getState().clear()
+    return { point: basePoint, wallSnap: null, guides: [], wallIds: [] }
+  }
+
+  const movingId = input.movingId ?? SURFACE_SNAP_MOVING_ID
+  const candidates =
+    input.candidates ??
+    collectAlignmentAnchors(nodes, input.excludeId ?? movingId, input.levelId ?? null)
+
+  if (candidates.length === 0) {
+    useAlignmentGuides.getState().clear()
+    return { point: basePoint, wallSnap: null, guides: [], wallIds: [] }
+  }
+
+  const alignment = resolveAlignment({
+    moving: [{ nodeId: movingId, kind: 'corner', x: basePoint[0], z: basePoint[1] }],
+    candidates,
+    threshold: input.threshold ?? SURFACE_ALIGNMENT_THRESHOLD_M,
+  })
+
+  useAlignmentGuides.getState().set(alignment.guides)
+
+  if (!alignment.snap) {
+    return { point: basePoint, wallSnap: null, guides: alignment.guides, wallIds: [] }
+  }
+
+  return {
+    point: [basePoint[0] + alignment.snap.dx, basePoint[1] + alignment.snap.dz],
+    wallSnap: null,
+    guides: alignment.guides,
+    wallIds: [],
+  }
+}