@pascal-app/editor 0.9.1 → 1.0.0-beta.1

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

@@ -1,9 +1,17 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  DEFAULT_ANGLE_STEP,
+  DEFAULT_LEVEL_HEIGHT,
   type DoorNode,
+  GROUND_SUPPORT_ID,
   getScaledDimensions,
   type ItemNode,
+  resolveWallSupportSlabPatch,
+  runAsSingleSceneHistoryStep,
+  snapPointAlongAngleRay,
+  spatialGridManager,
+  terrainSupportLift,
   useScene,
   type WallNode,
   WallNode as WallSchema,
@@ -11,51 +19,58 @@ import {
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { sfxEmitter } from '../../../lib/sfx-bus'
-import useEditor from '../../../store/use-editor'
+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,
+  wallIdsAtSnapPoint,
 } 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
-// Smallest available grid snap. Used as a precision-mode step (Shift +
-// drag) so a drag can land on values the regular grid skips.
-export const WALL_FINE_GRID_STEP = 0.05
 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
 }
 
 export function getSegmentGridStep(): number {
-  return useEditor.getState().gridSnapStep
+  // 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
 }
 
@@ -63,36 +78,11 @@ 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,
-  /**
-   * Optional grid-snap callback. Lets the caller route the final
-   * snap through a world-XZ grid (or any other axis system) instead
-   * of the local-axis grid `snapPointToGrid` uses. When omitted,
-   * falls back to the local-axis snap at `step`.
-   */
-  gridSnap?: (point: WallPlanPoint) => WallPlanPoint,
-): 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)
-  const point: WallPlanPoint = [
-    start[0] + Math.cos(snappedAngle) * distance,
-    start[1] + Math.sin(snappedAngle) * distance,
-  ]
-  return gridSnap ? gridSnap(point) : snapPointToGrid(point, step)
-}
-
-export function getWallAngleSnapStep(step = getSegmentGridStep()): number {
-  return WALL_ANGLE_SNAP_BY_GRID_STEP[step] ?? DEFAULT_WALL_ANGLE_SNAP_STEP
-}
-
-function splitWallAtPoint(wall: WallNode, splitPoint: WallPlanPoint): [WallNode, WallNode] {
+function splitWallAtPoint(
+  wall: WallNode,
+  splitPoint: WallPlanPoint,
+  nodes: ReturnType<typeof useScene.getState>['nodes'],
+): [WallNode, WallNode] {
   const { id: _id, parentId: _parentId, children, ...rest } = wall
 
   const first = WallSchema.parse({
@@ -108,7 +98,24 @@ function splitWallAtPoint(wall: WallNode, splitPoint: WallPlanPoint): [WallNode,
     children: [],
   })
 
-  return [first, second]
+  if (wall.supportSlabId !== GROUND_SUPPORT_ID || !wall.parentId) {
+    return [first, second]
+  }
+
+  const levelId = wall.parentId
+  const originalElevation =
+    (terrainSupportLift(nodes, levelId, wall.start[0], wall.start[1]) ?? 0) +
+    (wall.supportOffset ?? 0)
+  const rebase = (segment: WallNode): WallNode => {
+    const terrainElevation =
+      terrainSupportLift(nodes, levelId, segment.start[0], segment.start[1]) ?? 0
+    const supportOffset = originalElevation - terrainElevation
+    return {
+      ...segment,
+      supportOffset: Math.abs(supportOffset) > 1e-6 ? supportOffset : undefined,
+    }
+  }
+  return [rebase(first), rebase(second)]
 }
 
 function pointsEqual(a: WallPlanPoint, b: WallPlanPoint, tolerance = 1e-6): boolean {
@@ -118,6 +125,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 ?? [])
@@ -132,13 +140,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
   }
 
@@ -290,12 +305,16 @@ 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 }
   }
 
-  const [first, second] = splitWallAtPoint(wallToSplit, intersection.point)
+  const [first, second] = splitWallAtPoint(wallToSplit, intersection.point, nodes)
   const attachmentUpdates = buildAttachmentMigrationPlan(
     wallToSplit,
     intersection.point,
@@ -323,13 +342,51 @@ function splitWallIfNeeded(
   }
 }
 
+/**
+ * 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,
+  )
+
+  const intersection = findWallIntersection(point, walls, radius, ignoreWallIds)
+  const split = splitWallIfNeeded(intersection, walls, nodes, createNodes, updateNodes, deleteNode)
+  return split ? split.point : null
+}
+
 type SnapWallDraftArgs = {
   point: WallPlanPoint
   walls: WallNode[]
   start?: WallPlanPoint
   angleSnap?: boolean
   ignoreWallIds?: string[]
-  /** Override the grid step (e.g. `WALL_FINE_GRID_STEP` for precision mode). */
+  bypassSnap?: boolean
+  /** Override the grid step. */
   step?: number
   /**
    * Magnetic snapping to existing wall geometry (corners, midpoints,
@@ -345,6 +402,8 @@ type SnapWallDraftArgs = {
    * 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 {
@@ -354,34 +413,75 @@ export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSn
     start,
     angleSnap = false,
     ignoreWallIds,
+    bypassSnap = false,
     step: overrideStep,
     magnetic = true,
     gridSnap,
+    snapRadii,
   } = args
 
+  if (bypassSnap) return { point, snap: null, targetWallIds: [] }
+
   // 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)
+    const special = findWallSpecialPointSnap(point, walls, ignoreWallIds, snapRadii)
     if (special) return special
   }
 
   const step = overrideStep ?? getSegmentGridStep()
-  const angleStep = getWallAngleSnapStep(step)
-  const basePoint =
+  // 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, gridSnap)
+      ? [...snapPointAlongAngleRay(start, point, DEFAULT_ANGLE_STEP, step)]
       : gridSnap
         ? gridSnap(point)
         : snapPointToGrid(point, step)
 
   if (magnetic) {
-    const wallSnap = findWallSnapTarget(basePoint, walls, { ignoreWallIds })
-    if (wallSnap) return { point: wallSnap, snap: 'wall' }
+    const wallSnap = findWallSnapTarget(basePoint, walls, {
+      ignoreWallIds,
+      radius: snapRadii?.wall,
+    })
+    if (wallSnap) {
+      return {
+        point: wallSnap,
+        snap: 'wall',
+        targetWallIds: wallIdsAtSnapPoint(wallSnap, walls, ignoreWallIds),
+      }
+    }
+    return { point: basePoint, snap: null, targetWallIds: [] }
   }
 
-  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',
+      targetWallIds: wallIdsAtSnapPoint(connectWall, walls, ignoreWallIds),
+    }
+  }
+
+  return { point: basePoint, snap: null, targetWallIds: [] }
 }
 
 export function snapWallDraftPoint(args: SnapWallDraftArgs): WallPlanPoint {
@@ -392,9 +492,45 @@ export function isSegmentLongEnough(start: WallPlanPoint, end: WallPlanPoint): b
   return distanceSquared(start, end) >= WALL_MIN_LENGTH * WALL_MIN_LENGTH
 }
 
+export type WallConstructionOptions = {
+  /** Pointer-decided maximum support elevation in level-local metres. */
+  supportCap?: number | null
+  /** Support source selected by the first click or inherited from a snapped wall. */
+  preferredSupportSlabId?: string | null
+  /** Frozen level-local Y shown by the draft ghost. */
+  constructionElevation?: number | null
+  /** Height shown by the draft ghost. */
+  constructionHeight?: number | null
+}
+
+export function resolveTerrainWallConstructionOptions(
+  nodes: Record<string, AnyNode>,
+  levelId: string,
+  point: WallPlanPoint,
+  defaults?: Record<string, unknown>,
+): WallConstructionOptions | undefined {
+  const constructionElevation = terrainSupportLift(nodes, levelId, point[0], point[1])
+  if (constructionElevation == null) return undefined
+
+  const level = nodes[levelId]
+  const constructionHeight =
+    typeof defaults?.height === 'number'
+      ? defaults.height
+      : level?.type === 'level'
+        ? (level.height ?? DEFAULT_LEVEL_HEIGHT)
+        : DEFAULT_LEVEL_HEIGHT
+
+  return {
+    constructionElevation,
+    constructionHeight,
+    supportCap: constructionElevation,
+  }
+}
+
 export function createWallOnCurrentLevel(
   start: WallPlanPoint,
   end: WallPlanPoint,
+  options?: WallConstructionOptions,
 ): WallNode | null {
   const currentLevelId = useViewer.getState().selection.levelId
   const { createNode, createNodes, deleteNode, nodes } = useScene.getState()
@@ -411,61 +547,121 @@ 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
-  }
-
-  const startIntersection = findWallIntersection(resolvedStart, workingWalls)
-  const splitStart = splitWallIfNeeded(
-    startIntersection,
-    workingWalls,
-    nodes,
-    createNodes,
-    updateNodes,
-    deleteNode,
-  )
-  if (splitStart) {
-    workingWalls = splitStart.walls
-    resolvedStart = splitStart.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
+    }
 
-  if (!isSegmentLongEnough(resolvedStart, resolvedEnd) || pointsEqual(resolvedStart, resolvedEnd)) {
-    return null
-  }
+    const startIntersection = findWallIntersection(resolvedStart, workingWalls, joinRadius)
+    const splitStart = splitWallIfNeeded(
+      startIntersection,
+      workingWalls,
+      nodes,
+      createNodes,
+      updateNodes,
+      deleteNode,
+    )
+    if (splitStart) {
+      workingWalls = splitStart.walls
+      resolvedStart = splitStart.point
+    }
 
-  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
-  }
+    if (
+      !isSegmentLongEnough(resolvedStart, resolvedEnd) ||
+      pointsEqual(resolvedStart, resolvedEnd)
+    ) {
+      return null
+    }
 
-  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,
-  })
+    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
+    }
 
-  createNode(wall, currentLevelId)
-  sfxEmitter.emit('sfx:structure-build')
+    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)
+    const createdWall = useScene.getState().nodes[wall.id]
+    if (createdWall?.type === 'wall') {
+      const terrainBase = terrainSupportLift(
+        useScene.getState().nodes,
+        currentLevelId,
+        createdWall.start[0],
+        createdWall.start[1],
+      )
+      const preferredSupportSlabId =
+        options?.preferredSupportSlabId ??
+        (options?.constructionElevation != null && terrainBase != null ? GROUND_SUPPORT_ID : null)
+      const supportPatch = resolveWallSupportSlabPatch(createdWall, useScene.getState().nodes, {
+        maxElevation: options?.supportCap ?? null,
+        preferredSlabId: preferredSupportSlabId,
+      })
+      const supportSlabId = supportPatch.supportSlabId
+      const sourceSupport = spatialGridManager.getSlabSupportForWall(
+        currentLevelId,
+        createdWall.start,
+        createdWall.end,
+        createdWall.curveOffset,
+        createdWall.thickness,
+        supportSlabId,
+        options?.supportCap ?? null,
+      )
+      const supportOffset =
+        options?.constructionElevation == null
+          ? undefined
+          : options.constructionElevation - sourceSupport.elevation
+      const preserveDraftHeight =
+        createdWall.height == null &&
+        options?.constructionHeight != null &&
+        options.constructionElevation != null &&
+        (terrainBase != null || Math.abs(options.constructionElevation) > 1e-6)
+      useScene.getState().updateNode(createdWall.id, {
+        ...supportPatch,
+        height: preserveDraftHeight
+          ? (options?.constructionHeight ?? createdWall.height)
+          : createdWall.height,
+        supportOffset:
+          supportOffset != null && Math.abs(supportOffset) > 1e-6 ? supportOffset : undefined,
+      })
+    }
+    sfxEmitter.emit('sfx:structure-build')
 
-  return wall
+    const committedWall = useScene.getState().nodes[wall.id]
+    return committedWall?.type === 'wall' ? committedWall : wall
+  })
 }

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

@@ -1,6 +1,7 @@
 import { describe, expect, test } from 'bun:test'
 import type { WallNode } from '@pascal-app/core'
 import {
+  chainEndJoinsExistingWall,
   findWallSnapTarget,
   findWallSpecialPointSnap,
   type WallPlanPoint,
@@ -47,6 +48,14 @@ describe('findWallSpecialPointSnap', () => {
     expect(result?.snap).toBe('intersection')
     expect(result?.point[0]).toBeCloseTo(1, 6)
     expect(result?.point[1]).toBeCloseTo(0, 6)
+    expect(result?.targetWallIds).toEqual(['a', 'b'])
+  })
+
+  test('keeps every wall that shares a snapped endpoint as provenance', () => {
+    const walls = [makeWall([0, 0], [4, 0], 'a'), makeWall([0, 0], [0, 4], 'b')]
+    const result = findWallSpecialPointSnap([0.1, 0.1], walls)
+    expect(result?.point).toEqual([0, 0])
+    expect(result?.targetWallIds).toEqual(['a', 'b'])
   })
 
   test('corner wins over a midpoint when both are in range', () => {
@@ -62,6 +71,43 @@ describe('findWallSpecialPointSnap', () => {
     // 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)', () => {
@@ -76,4 +122,10 @@ describe('findWallSnapTarget (edge / along-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()
+  })
 })