@pascal-app/editor 0.8.0 → 0.9.2

package/src/components/tools/wall/wall-drafting.ts

@@ -1,12 +1,12 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  DEFAULT_ANGLE_STEP,
   type DoorNode,
   getScaledDimensions,
-  getWallCurveFrameAt,
-  getWallCurveLength,
   type ItemNode,
-  isCurvedWall,
+  runAsSingleSceneHistoryStep,
+  snapPointAlongAngleRay,
   useScene,
   type WallNode,
   WallNode as WallSchema,
@@ -14,38 +14,57 @@ import {
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { sfxEmitter } from '../../../lib/sfx-bus'
-import useEditor from '../../../store/use-editor'
-
-export type WallPlanPoint = [number, number]
+import { resolveSnapFlags } from '../../../lib/snapping-mode'
+import useEditor, { getActiveSnappingMode, isMagneticSnapActive } from '../../../store/use-editor'
+import {
+  distanceSquared,
+  findWallSnapTarget,
+  findWallSpecialPointSnap,
+  projectPointOntoWall,
+  WALL_CONNECT_SNAP_RADIUS,
+  WALL_JOIN_SNAP_RADIUS,
+  type WallDraftSnapResult,
+  type WallPlanPoint,
+  type WallSnapRadii,
+} from './wall-snap-geometry'
+
+// The pure snap geometry lives in `./wall-snap-geometry`; re-exported here so
+// existing importers (fence drafting, the editor barrel) keep their paths.
+export {
+  chainEndJoinsExistingWall,
+  findWallSnapTarget,
+  WALL_CONNECT_SNAP_RADIUS,
+  WALL_JOIN_SNAP_RADIUS,
+  type WallDraftSnapKind,
+  type WallDraftSnapResult,
+  type WallPlanPoint,
+  type WallSnapRadii,
+} from './wall-snap-geometry'
 
 export const WALL_GRID_STEP = 0.5
-export const WALL_JOIN_SNAP_RADIUS = 0.35
 export const WALL_MIN_LENGTH = 0.01
-const DEFAULT_WALL_ANGLE_SNAP_STEP = Math.PI / 4
-
-const WALL_ANGLE_SNAP_BY_GRID_STEP: Record<number, number> = {
-  0.5: Math.PI / 4,
-  0.25: Math.PI / 8,
-  0.1: Math.PI / 12,
-  0.05: Math.PI / 36,
-}
+// An endpoint projecting within this distance of an existing wall's corner
+// resolves to the corner without splitting — splitting there would mint a
+// sliver segment a hair longer than `WALL_MIN_LENGTH` that no snap radius
+// can ever target again.
+const WALL_SPLIT_ENDPOINT_EPSILON = 0.02
 
 type WallSplitIntersection = {
-  wallId: WallNode['id']
+  /** `null` = snap-only outcome: resolve to `point` but split no wall. */
+  wallId: WallNode['id'] | null
   point: WallPlanPoint
 }
 
-function distanceSquared(a: WallPlanPoint, b: WallPlanPoint): number {
-  const dx = a[0] - b[0]
-  const dz = a[1] - b[1]
-  return dx * dx + dz * dz
-}
-
-export function getWallGridStep(): number {
-  return useEditor.getState().gridSnapStep
+export function getSegmentGridStep(): number {
+  // A 0 step means "no grid lattice" — every grid-snap consumer guards on
+  // `step <= 0` and returns the raw value, so disabling grid here suppresses
+  // the lattice for walls, fences, and every node move/affordance that reads
+  // this choke point, without retuning their snap math.
+  return resolveSnapFlags(getActiveSnappingMode()).grid ? useEditor.getState().gridSnapStep : 0
 }
 
 export function snapScalarToGrid(value: number, step = WALL_GRID_STEP): number {
+  if (step <= 0) return value
   return Math.round(value / step) * step
 }
 
@@ -53,46 +72,6 @@ export function snapPointToGrid(point: WallPlanPoint, step = WALL_GRID_STEP): Wa
   return [snapScalarToGrid(point[0], step), snapScalarToGrid(point[1], step)]
 }
 
-export function snapPointTo45Degrees(
-  start: WallPlanPoint,
-  cursor: WallPlanPoint,
-  step = WALL_GRID_STEP,
-  angleStep = DEFAULT_WALL_ANGLE_SNAP_STEP,
-): WallPlanPoint {
-  const dx = cursor[0] - start[0]
-  const dz = cursor[1] - start[1]
-  const angle = Math.atan2(dz, dx)
-  const snappedAngle = Math.round(angle / angleStep) * angleStep
-  const distance = Math.sqrt(dx * dx + dz * dz)
-
-  return snapPointToGrid(
-    [start[0] + Math.cos(snappedAngle) * distance, start[1] + Math.sin(snappedAngle) * distance],
-    step,
-  )
-}
-
-export function getWallAngleSnapStep(step = getWallGridStep()): number {
-  return WALL_ANGLE_SNAP_BY_GRID_STEP[step] ?? DEFAULT_WALL_ANGLE_SNAP_STEP
-}
-
-function projectPointOntoWall(point: WallPlanPoint, wall: WallNode): WallPlanPoint | null {
-  const [x1, z1] = wall.start
-  const [x2, z2] = wall.end
-  const dx = x2 - x1
-  const dz = z2 - z1
-  const lengthSquared = dx * dx + dz * dz
-  if (lengthSquared < 1e-9) {
-    return null
-  }
-
-  const t = ((point[0] - x1) * dx + (point[1] - z1) * dz) / lengthSquared
-  if (t <= 0 || t >= 1) {
-    return null
-  }
-
-  return [x1 + dx * t, z1 + dz * t]
-}
-
 function splitWallAtPoint(wall: WallNode, splitPoint: WallPlanPoint): [WallNode, WallNode] {
   const { id: _id, parentId: _parentId, children, ...rest } = wall
 
@@ -119,6 +98,7 @@ function pointsEqual(a: WallPlanPoint, b: WallPlanPoint, tolerance = 1e-6): bool
 function findWallIntersection(
   point: WallPlanPoint,
   walls: WallNode[],
+  radius: number,
   ignoreWallIds?: string[],
 ): WallSplitIntersection | null {
   const ignore = new Set(ignoreWallIds ?? [])
@@ -133,13 +113,20 @@ function findWallIntersection(
 
     const candidateDistanceSquared = distanceSquared(point, projected)
     if (
-      candidateDistanceSquared > WALL_JOIN_SNAP_RADIUS * WALL_JOIN_SNAP_RADIUS ||
+      candidateDistanceSquared > radius * radius ||
       candidateDistanceSquared >= bestDistanceSquared
     ) {
       continue
     }
 
-    best = { wallId: wall.id, point: projected }
+    const nearCorner = ([wall.start, wall.end] as WallPlanPoint[]).find(
+      (corner) =>
+        distanceSquared(projected, corner) <=
+        WALL_SPLIT_ENDPOINT_EPSILON * WALL_SPLIT_ENDPOINT_EPSILON,
+    )
+    best = nearCorner
+      ? { wallId: null, point: [nearCorner[0], nearCorner[1]] }
+      : { wallId: wall.id, point: projected }
     bestDistanceSquared = candidateDistanceSquared
   }
 
@@ -291,6 +278,10 @@ function splitWallIfNeeded(
 ): { walls: WallNode[]; point: WallPlanPoint } | null {
   if (!intersection) return null
 
+  if (!intersection.wallId) {
+    return { walls, point: intersection.point }
+  }
+
   const wallToSplit = walls.find((wall) => wall.id === intersection.wallId)
   if (!wallToSplit) {
     return { walls, point: intersection.point }
@@ -324,76 +315,141 @@ function splitWallIfNeeded(
   }
 }
 
-export function findWallSnapTarget(
-  point: WallPlanPoint,
-  walls: WallNode[],
-  options?: { ignoreWallIds?: string[]; radius?: number },
-): WallPlanPoint | null {
-  const ignoreWallIds = new Set(options?.ignoreWallIds ?? [])
-  const radiusSquared = (options?.radius ?? WALL_JOIN_SNAP_RADIUS) ** 2
-  let bestTarget: WallPlanPoint | null = null
-  let bestDistanceSquared = Number.POSITIVE_INFINITY
-
-  for (const wall of walls) {
-    if (ignoreWallIds.has(wall.id)) {
-      continue
-    }
-
-    const candidates: Array<WallPlanPoint | null> = [wall.start, wall.end]
-
-    if (isCurvedWall(wall)) {
-      const sampleCount = Math.max(8, Math.ceil(getWallCurveLength(wall) / 0.3))
-      for (let index = 0; index <= sampleCount; index += 1) {
-        const frame = getWallCurveFrameAt(wall, index / sampleCount)
-        candidates.push([frame.point.x, frame.point.y])
-      }
-    } else {
-      candidates.push(projectPointOntoWall(point, wall))
-    }
-    for (const candidate of candidates) {
-      if (!candidate) {
-        continue
-      }
-
-      const candidateDistanceSquared = distanceSquared(point, candidate)
-      if (
-        candidateDistanceSquared > radiusSquared ||
-        candidateDistanceSquared >= bestDistanceSquared
-      ) {
-        continue
-      }
-
-      bestTarget = candidate
-      bestDistanceSquared = candidateDistanceSquared
-    }
-  }
+/**
+ * Commit-time split resolution for an endpoint MOVE — the sibling of the
+ * inline resolution in `createWallOnCurrentLevel`: when a moved endpoint is
+ * dropped on another wall's interior, split that host exactly like the draw
+ * path (duplicate props, migrate attachments by span, skip the split when an
+ * opening straddles the point). Mutates the scene store (create halves /
+ * migrate attachments / delete host), so callers MUST run it inside the same
+ * `runAsSingleSceneHistoryStep` as their endpoint write.
+ *
+ * Returns the resolved endpoint (projection onto the host, or a nearby corner
+ * when the drop is within `WALL_SPLIT_ENDPOINT_EPSILON` of one — corner joins
+ * are not splits), or `null` when the point lands on no wall.
+ */
+export function resolveEndpointWallSplit(args: {
+  point: WallPlanPoint
+  /** Level the moved wall lives on — only its walls are split candidates. */
+  levelId: string | null
+  /** The moved wall + every wall receiving an endpoint update in the same commit. */
+  ignoreWallIds: string[]
+  /**
+   * Capture radius. The endpoint already snapped onto the wall body during
+   * the drag, so the tight connect radius (drop genuinely on the wall) is
+   * the default.
+   */
+  radius?: number
+}): WallPlanPoint | null {
+  const { point, levelId, ignoreWallIds, radius = WALL_CONNECT_SNAP_RADIUS } = args
+  const { nodes, createNodes, updateNodes, deleteNode } = useScene.getState()
+  const walls = Object.values(nodes).filter(
+    (node): node is WallNode => node?.type === 'wall' && (node.parentId ?? null) === levelId,
+  )
 
-  return bestTarget
+  const intersection = findWallIntersection(point, walls, radius, ignoreWallIds)
+  const split = splitWallIfNeeded(intersection, walls, nodes, createNodes, updateNodes, deleteNode)
+  return split ? split.point : null
 }
 
-export function snapWallDraftPoint(args: {
+type SnapWallDraftArgs = {
   point: WallPlanPoint
   walls: WallNode[]
   start?: WallPlanPoint
   angleSnap?: boolean
   ignoreWallIds?: string[]
-}): WallPlanPoint {
-  const { point, walls, start, angleSnap = false, ignoreWallIds } = args
-  const step = getWallGridStep()
-  const angleStep = getWallAngleSnapStep(step)
-  const basePoint =
+  bypassSnap?: boolean
+  /** Override the grid step. */
+  step?: number
+  /**
+   * Magnetic snapping to existing wall geometry (corners, midpoints,
+   * crossings, wall bodies). When `false`, only grid/angle snap applies and
+   * `snap` is always `null`. Defaults to `true` so callers that don't care
+   * keep the prior behaviour.
+   */
+  magnetic?: boolean
+  /**
+   * Optional grid-snap override. Lets the caller route grid snapping
+   * through a world-XZ aligned snap (so a rotated building's draft
+   * lands on the visible grid). When omitted, falls back to the
+   * local-axis grid at `step`.
+   */
+  gridSnap?: (point: WallPlanPoint) => WallPlanPoint
+  /** Optional magnetic snap radii. Omitted means wall tools keep their defaults. */
+  snapRadii?: WallSnapRadii
+}
+
+export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSnapResult {
+  const {
+    point,
+    walls,
+    start,
+    angleSnap = false,
+    ignoreWallIds,
+    bypassSnap = false,
+    step: overrideStep,
+    magnetic = true,
+    gridSnap,
+    snapRadii,
+  } = args
+
+  if (bypassSnap) return { point, snap: null }
+
+  // Discrete special points (corner / midpoint / crossing) are taken from the
+  // raw cursor so an interim grid snap can't mask them. A corner always wins,
+  // then the nearer of midpoint / crossing — see `findWallSpecialPointSnap`.
+  if (magnetic) {
+    const special = findWallSpecialPointSnap(point, walls, ignoreWallIds, snapRadii)
+    if (special) return special
+  }
+
+  const step = overrideStep ?? getSegmentGridStep()
+  // The angle path snaps the distance ALONG the 15° ray — a scalar, the
+  // same in world and local frames — so the `gridSnap` world-grid override
+  // only applies when the angle lock is off.
+  const basePoint: WallPlanPoint =
     start && angleSnap
-      ? snapPointTo45Degrees(start, point, step, angleStep)
-      : snapPointToGrid(point, step)
+      ? [...snapPointAlongAngleRay(start, point, DEFAULT_ANGLE_STEP, step)]
+      : gridSnap
+        ? gridSnap(point)
+        : snapPointToGrid(point, step)
 
-  return (
-    findWallSnapTarget(basePoint, walls, {
+  if (magnetic) {
+    const wallSnap = findWallSnapTarget(basePoint, walls, {
       ignoreWallIds,
-    }) ?? basePoint
-  )
+      radius: snapRadii?.wall,
+    })
+    if (wallSnap) return { point: wallSnap, snap: 'wall' }
+    return { point: basePoint, snap: null }
+  }
+
+  // Non-magnetic modes (grid / off / angles): connectivity still sticks so a
+  // room can close, but only within a tight radius — placement elsewhere is left
+  // to the mode (grid quantise / angle lock / free). Snap from the already
+  // positioned `basePoint` so the mode's placement is respected right up to the
+  // wall, then the last few cm stick onto it (and the beacon shows).
+  const connectRadii: WallSnapRadii = {
+    endpoint: WALL_CONNECT_SNAP_RADIUS,
+    midpoint: WALL_CONNECT_SNAP_RADIUS,
+    intersection: WALL_CONNECT_SNAP_RADIUS,
+    wall: WALL_CONNECT_SNAP_RADIUS,
+  }
+  const connectSpecial = findWallSpecialPointSnap(basePoint, walls, ignoreWallIds, connectRadii)
+  if (connectSpecial) return connectSpecial
+  const connectWall = findWallSnapTarget(basePoint, walls, {
+    ignoreWallIds,
+    radius: WALL_CONNECT_SNAP_RADIUS,
+  })
+  if (connectWall) return { point: connectWall, snap: 'wall' }
+
+  return { point: basePoint, snap: null }
+}
+
+export function snapWallDraftPoint(args: SnapWallDraftArgs): WallPlanPoint {
+  return snapWallDraftPointDetailed(args).point
 }
 
-export function isWallLongEnough(start: WallPlanPoint, end: WallPlanPoint): boolean {
+export function isSegmentLongEnough(start: WallPlanPoint, end: WallPlanPoint): boolean {
   return distanceSquared(start, end) >= WALL_MIN_LENGTH * WALL_MIN_LENGTH
 }
 
@@ -405,7 +461,7 @@ export function createWallOnCurrentLevel(
   const { createNode, createNodes, deleteNode, nodes } = useScene.getState()
   const { updateNodes } = useScene.getState()
 
-  if (!(currentLevelId && isWallLongEnough(start, end))) {
+  if (!(currentLevelId && isSegmentLongEnough(start, end))) {
     return null
   }
 
@@ -416,56 +472,77 @@ export function createWallOnCurrentLevel(
   let resolvedStart = start
   let resolvedEnd = end
 
-  const endIntersection = findWallIntersection(resolvedEnd, workingWalls)
-  const splitEnd = splitWallIfNeeded(
-    endIntersection,
-    workingWalls,
-    nodes,
-    createNodes,
-    updateNodes,
-    deleteNode,
-  )
-  if (splitEnd) {
-    workingWalls = splitEnd.walls
-    resolvedEnd = splitEnd.point
-  }
+  // The corner-join / wall-split resolution follows the snapping mode like the
+  // draft preview does: magnetic ('lines') keeps the generous join radius,
+  // every other mode uses the same tight connect radius the draft path already
+  // sticks endpoints with. So an endpoint the user saw connect to a wall body
+  // actually splits that wall (and redistributes its attachments) in every
+  // mode, while `'off'` / `'angles'` gain no residual long-range snap.
+  const joinRadius = isMagneticSnapActive() ? WALL_JOIN_SNAP_RADIUS : WALL_CONNECT_SNAP_RADIUS
+
+  // One undo step for the whole commit: the split ops (create halves, migrate
+  // attachments, delete host) plus the new wall each push their own history
+  // entry, and a single Ctrl-Z must not strand a half-split wall network.
+  return runAsSingleSceneHistoryStep(useScene, () => {
+    const endIntersection = findWallIntersection(resolvedEnd, workingWalls, joinRadius)
+    const splitEnd = splitWallIfNeeded(
+      endIntersection,
+      workingWalls,
+      nodes,
+      createNodes,
+      updateNodes,
+      deleteNode,
+    )
+    if (splitEnd) {
+      workingWalls = splitEnd.walls
+      resolvedEnd = splitEnd.point
+    }
 
-  const startIntersection = findWallIntersection(resolvedStart, workingWalls)
-  const splitStart = splitWallIfNeeded(
-    startIntersection,
-    workingWalls,
-    nodes,
-    createNodes,
-    updateNodes,
-    deleteNode,
-  )
-  if (splitStart) {
-    workingWalls = splitStart.walls
-    resolvedStart = splitStart.point
-  }
+    const startIntersection = findWallIntersection(resolvedStart, workingWalls, joinRadius)
+    const splitStart = splitWallIfNeeded(
+      startIntersection,
+      workingWalls,
+      nodes,
+      createNodes,
+      updateNodes,
+      deleteNode,
+    )
+    if (splitStart) {
+      workingWalls = splitStart.walls
+      resolvedStart = splitStart.point
+    }
 
-  if (!isWallLongEnough(resolvedStart, resolvedEnd) || pointsEqual(resolvedStart, resolvedEnd)) {
-    return null
-  }
+    if (
+      !isSegmentLongEnough(resolvedStart, resolvedEnd) ||
+      pointsEqual(resolvedStart, resolvedEnd)
+    ) {
+      return null
+    }
 
-  const duplicateWall = workingWalls.some(
-    (wall) =>
-      (pointsEqual(wall.start, resolvedStart) && pointsEqual(wall.end, resolvedEnd)) ||
-      (pointsEqual(wall.start, resolvedEnd) && pointsEqual(wall.end, resolvedStart)),
-  )
-  if (duplicateWall) {
-    return null
-  }
+    const duplicateWall = workingWalls.some(
+      (wall) =>
+        (pointsEqual(wall.start, resolvedStart) && pointsEqual(wall.end, resolvedEnd)) ||
+        (pointsEqual(wall.start, resolvedEnd) && pointsEqual(wall.end, resolvedStart)),
+    )
+    if (duplicateWall) {
+      return null
+    }
 
-  const wallCount = Object.values(nodes).filter((node) => node.type === 'wall').length
-  const wall = WallSchema.parse({
-    name: `Wall ${wallCount + 1}`,
-    start: resolvedStart,
-    end: resolvedEnd,
+    const wallCount = Object.values(nodes).filter((node) => node.type === 'wall').length
+    // A placed wall preset seeds `toolDefaults.wall` (thickness, height,
+    // materials, sides) before the tool activates; merge those first so the
+    // drawn wall reproduces the preset. Identity + endpoints always win.
+    const defaults = useEditor.getState().toolDefaults.wall ?? {}
+    const wall = WallSchema.parse({
+      ...defaults,
+      name: `Wall ${wallCount + 1}`,
+      start: resolvedStart,
+      end: resolvedEnd,
+    })
+
+    createNode(wall, currentLevelId)
+    sfxEmitter.emit('sfx:structure-build')
+
+    return wall
   })
-
-  createNode(wall, currentLevelId)
-  sfxEmitter.emit('sfx:structure-build')
-
-  return wall
 }

package/src/components/tools/wall/wall-snap-geometry.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, test } from 'bun:test'
+import type { WallNode } from '@pascal-app/core'
+import {
+  chainEndJoinsExistingWall,
+  findWallSnapTarget,
+  findWallSpecialPointSnap,
+  type WallPlanPoint,
+} from './wall-snap-geometry'
+
+function makeWall(start: WallPlanPoint, end: WallPlanPoint, id?: string): WallNode {
+  return {
+    object: 'node',
+    id: (id ?? `wall_${start.join('_')}_${end.join('_')}`) as WallNode['id'],
+    type: 'wall',
+    name: 'Wall',
+    parentId: null,
+    visible: true,
+    metadata: {},
+    children: [],
+    start,
+    end,
+    thickness: 0.1,
+    frontSide: 'unknown',
+    backSide: 'unknown',
+  } as unknown as WallNode
+}
+
+describe('findWallSpecialPointSnap', () => {
+  test('snaps to a wall corner (endpoint) when near it', () => {
+    const walls = [makeWall([0, 0], [4, 0])]
+    const result = findWallSpecialPointSnap([0.1, 0.1], walls)
+    expect(result?.snap).toBe('endpoint')
+    expect(result?.point).toEqual([0, 0])
+  })
+
+  test('snaps to a wall midpoint when near it (not a corner)', () => {
+    const walls = [makeWall([0, 0], [4, 0])]
+    const result = findWallSpecialPointSnap([2.1, 0.2], walls)
+    expect(result?.snap).toBe('midpoint')
+    expect(result?.point).toEqual([2, 0])
+  })
+
+  test('snaps to the crossing of two walls (intersection)', () => {
+    // A runs along z=0; B crosses it at x=1. B's own midpoint is [1,1], far
+    // from the crossing, so the snap is the intersection, not a midpoint.
+    const walls = [makeWall([0, 0], [4, 0], 'a'), makeWall([1, -1], [1, 3], 'b')]
+    const result = findWallSpecialPointSnap([1.1, 0.1], walls)
+    expect(result?.snap).toBe('intersection')
+    expect(result?.point[0]).toBeCloseTo(1, 6)
+    expect(result?.point[1]).toBeCloseTo(0, 6)
+  })
+
+  test('corner wins over a midpoint when both are in range', () => {
+    const walls = [makeWall([0, 0], [1, 0])]
+    const result = findWallSpecialPointSnap([0.9, 0.1], walls)
+    expect(result?.snap).toBe('endpoint')
+    expect(result?.point).toEqual([1, 0])
+  })
+
+  test('returns null when no special point is in range', () => {
+    const walls = [makeWall([0, 0], [4, 0])]
+    // Near the wall body but far from corner/midpoint — that's an edge snap,
+    // handled separately by findWallSnapTarget, not a special point.
+    expect(findWallSpecialPointSnap([1.2, 0.1], walls)).toBeNull()
+  })
+
+  test('honors tighter per-call radii without changing defaults', () => {
+    const walls = [makeWall([0, 0], [4, 0])]
+
+    expect(findWallSpecialPointSnap([0.34, 0], walls)?.snap).toBe('endpoint')
+    expect(findWallSpecialPointSnap([0.34, 0], walls, undefined, { endpoint: 0.3 })).toBeNull()
+  })
+})
+
+describe('chainEndJoinsExistingWall (chain termination)', () => {
+  test('true when the end lies on a non-chain wall interior (T junction)', () => {
+    const walls = [makeWall([0, 0], [4, 0], 'host'), makeWall([2, 2], [2, 0], 'chain_1')]
+    expect(chainEndJoinsExistingWall([2, 0], walls, ['chain_1'])).toBe(true)
+  })
+
+  test('true when the end lands on a non-chain wall endpoint', () => {
+    const walls = [makeWall([0, 0], [4, 0], 'host'), makeWall([6, 2], [4, 0], 'chain_1')]
+    expect(chainEndJoinsExistingWall([4, 0], walls, ['chain_1'])).toBe(true)
+  })
+
+  test('false when the end only touches the chain walls themselves', () => {
+    // Second segment doubles back onto the first one's midpoint — own-chain
+    // geometry is excluded, so the chain keeps going.
+    const walls = [makeWall([0, 0], [4, 0], 'chain_1'), makeWall([4, 0], [2, 0], 'chain_2')]
+    expect(chainEndJoinsExistingWall([2, 0], walls, ['chain_1', 'chain_2'])).toBe(false)
+  })
+
+  test('false for a dead end in free space', () => {
+    const walls = [makeWall([0, 0], [4, 0], 'host'), makeWall([0, 2], [2, 2], 'chain_1')]
+    expect(chainEndJoinsExistingWall([2, 2], walls, ['chain_1'])).toBe(false)
+  })
+
+  test('a near miss beyond the tolerance is not a join', () => {
+    const walls = [makeWall([0, 0], [4, 0], 'host')]
+    expect(chainEndJoinsExistingWall([2, 0.01], walls, [])).toBe(false)
+    expect(chainEndJoinsExistingWall([2, 0.0005], walls, [])).toBe(true)
+  })
+})
+
+describe('findWallSnapTarget (edge / along-wall)', () => {
+  test('projects onto a wall body within range', () => {
+    const walls = [makeWall([0, 0], [4, 0])]
+    const result = findWallSnapTarget([1.2, 0.1], walls)
+    expect(result?.[0]).toBeCloseTo(1.2, 6)
+    expect(result?.[1]).toBeCloseTo(0, 6)
+  })
+
+  test('returns null when too far from any wall', () => {
+    const walls = [makeWall([0, 0], [4, 0])]
+    expect(findWallSnapTarget([1.2, 2], walls)).toBeNull()
+  })
+
+  test('honors a tighter wall-body radius', () => {
+    const walls = [makeWall([0, 0], [4, 0])]
+
+    expect(findWallSnapTarget([1.2, 0.1], walls, { radius: 0.08 })).toBeNull()
+  })
+})