@pascal-app/editor 1.0.6 → 1.1.0

package/src/lib/wall-draw-variant.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, test } from 'bun:test'
 import { emitter } from '@pascal-app/core'
 import useEditor from '../store/use-editor'
+import { CONTINUATION_PROFILES } from './continuation'
 import { toolHudTitle } from './hud-title'
 import {
   getWallDrawVariant,
@@ -23,9 +24,9 @@ describe('Rooms variants', () => {
     ])
   })
 
-  test('default to the chain that closes into a room', () => {
-    expect(getWallDrawVariant()).toBe('polygon')
-    expect(wallDrawVariantOf('unknown')).toBe('polygon')
+  test('default to Rectangle', () => {
+    expect(wallDrawVariantOf(CONTINUATION_PROFILES.wall.default)).toBe('rectangle')
+    expect(wallDrawVariantOf('unknown')).toBe('rectangle')
   })
 
   test('picking one sets the wall tool drawing mode, and it sticks', () => {
@@ -61,11 +62,11 @@ describe('Rooms variants', () => {
 
   test('name the HUD after the variant in hand', () => {
     expect(toolHudTitle('wall', 'rectangle')).toEqual({
-      label: 'Rectangle room',
+      label: expect.objectContaining({ message: 'Rectangle room' }),
       icon: { kind: 'url', src: '/icons/room.webp' },
       shortcut: 'B',
     })
-    expect(toolHudTitle('wall', 'room')?.label).toBe('Polygon room')
-    expect(toolHudTitle('wall', 'single')?.label).toBe('Walls')
+    expect(toolHudTitle('wall', 'room')?.label.message).toBe('Polygon room')
+    expect(toolHudTitle('wall', 'single')?.label.message).toBe('Walls')
   })
 })

package/src/lib/wall-draw-variant.ts

@@ -1,6 +1,15 @@
-import { emitter } from '@pascal-app/core'
+import {
+  emitter,
+  type MessageDescriptor,
+  railingWallDefaults,
+  useScene,
+  type WallNode,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { create } from 'zustand'
 import useEditor from '../store/use-editor'
 import type { ContinuationMode } from './continuation'
+import { levelSeparatorLines } from './separator-lines'
 
 /**
  * How the wall tool draws, picked from the Build panel's Rooms group before
@@ -16,7 +25,7 @@ export type WallDrawVariantInfo = {
   /** Tile label. */
   label: string
   /** The name the HUD shows while the variant is armed. */
-  title: string
+  title: MessageDescriptor
   iconSrc: string
   /** Caption under the Rooms tiles: a bold lead, then the rest. */
   caption: { lead: string; rest: string }
@@ -27,7 +36,7 @@ export const WALL_DRAW_VARIANTS: readonly WallDrawVariantInfo[] = [
     id: 'rectangle',
     mode: 'rectangle',
     label: 'Rectangle',
-    title: 'Rectangle room',
+    title: /* i18n */ { id: 'editor.lib.wallDrawVariant.rectangleRoom', message: 'Rectangle room' },
     iconSrc: '/icons/room.webp',
     caption: {
       lead: 'Click two corners',
@@ -38,7 +47,7 @@ export const WALL_DRAW_VARIANTS: readonly WallDrawVariantInfo[] = [
     id: 'polygon',
     mode: 'room',
     label: 'Polygon',
-    title: 'Polygon room',
+    title: /* i18n */ { id: 'editor.lib.wallDrawVariant.polygonRoom', message: 'Polygon room' },
     iconSrc: '/icons/polygon-room.webp',
     caption: {
       lead: 'Click each corner,',
@@ -49,7 +58,7 @@ export const WALL_DRAW_VARIANTS: readonly WallDrawVariantInfo[] = [
     id: 'walls',
     mode: 'single',
     label: 'Walls',
-    title: 'Walls',
+    title: /* i18n */ { id: 'editor.lib.wallDrawVariant.walls', message: 'Walls' },
     iconSrc: '/icons/wall.webp',
     caption: {
       lead: 'Draw one wall at a time.',
@@ -66,7 +75,7 @@ export function getWallDrawVariantInfo(variant: WallDrawVariant): WallDrawVarian
 }
 
 export function wallDrawVariantOf(mode: ContinuationMode): WallDrawVariant {
-  return WALL_DRAW_VARIANTS.find((info) => info.mode === mode)?.id ?? 'polygon'
+  return WALL_DRAW_VARIANTS.find((info) => info.mode === mode)?.id ?? 'rectangle'
 }
 
 export function getWallDrawVariant(): WallDrawVariant {
@@ -89,3 +98,95 @@ export function selectWallDrawVariant(variant: WallDrawVariant): void {
   if (editor.mode === 'build' && editor.tool === 'wall') emitter.emit('tool:cancel')
   editor.setContinuation('wall', mode)
 }
+
+/**
+ * What the wall tool draws in place of plain walls: invisible walls (room separators no wall
+ * stands on) or railings.
+ */
+export type WallLineKind = 'invisible' | 'railing'
+
+/**
+ * The Walls variant's kinds, its sub-row in the Build panel: a plain wall (room detection
+ * sides it exterior or interior), an invisible wall, or a railing.
+ */
+export type WallKind = 'standard' | WallLineKind
+
+export const WALL_KINDS: ReadonlyArray<{ id: WallKind; label: MessageDescriptor }> = [
+  {
+    id: 'standard',
+    label: /* i18n */ { id: 'editor.lib.wallDrawVariant.kind.standard', message: 'Standard' },
+  },
+  {
+    id: 'invisible',
+    label: /* i18n */ { id: 'editor.lib.wallDrawVariant.kind.invisible', message: 'Invisible' },
+  },
+  {
+    id: 'railing',
+    label: /* i18n */ { id: 'editor.lib.wallDrawVariant.kind.railing', message: 'Railing' },
+  },
+]
+
+/** The line an invisible wall's draft is drawn at, metres. */
+export const INVISIBLE_WALL_DRAFT_THICKNESS = 0.01
+
+// Session-only, so it lives beside the persisted editor store, not in it.
+const useWallLineKindStore = create<{ lineKind: WallLineKind | null }>(() => ({
+  lineKind: null,
+}))
+
+export function getWallLineKind(): WallLineKind | null {
+  return useWallLineKindStore.getState().lineKind
+}
+
+/** The kind the Walls variant draws, for the Build panel's sub-row. */
+export function useWallKind(): WallKind {
+  return useWallLineKindStore((state) => state.lineKind ?? 'standard')
+}
+
+/**
+ * Pick what the Walls variant draws, for this session: it lasts while the wall tool draws
+ * Walls (`subscribeWallKindReset`). Switching while the tool is armed drops the in-flight
+ * draft, so a half-drawn wall never lands as another kind.
+ */
+export function selectWallKind(kind: WallKind): void {
+  const lineKind = kind === 'standard' ? null : kind
+  if (getWallLineKind() === lineKind) return
+  const editor = useEditor.getState()
+  if (editor.mode === 'build' && editor.tool === 'wall') emitter.emit('tool:cancel')
+  useWallLineKindStore.setState({ lineKind })
+}
+
+/** Back to plain walls once the wall tool is left or draws another variant. */
+export function subscribeWallKindReset(): () => void {
+  return useEditor.subscribe((state) => {
+    if (
+      state.mode === 'build' &&
+      state.tool === 'wall' &&
+      state.getContinuation('wall') === 'single'
+    )
+      return
+    if (getWallLineKind() !== null) useWallLineKindStore.setState({ lineKind: null })
+  })
+}
+
+/**
+ * What an invisible-wall draft snaps to besides walls: the current level's
+ * invisible walls, as lines (`separatorWallLine`), so a new one closes onto
+ * their ends and bodies — its old corner. Nothing while walls or railings draw.
+ */
+export function invisibleWallDraftSnapLines(): WallNode[] {
+  if (getWallLineKind() !== 'invisible') return []
+  return levelSeparatorLines(useScene.getState().nodes, useViewer.getState().selection.levelId)
+}
+
+/**
+ * The thickness the wall tool's drafts draw at: an invisible wall's line, a railing's, a
+ * placed preset's (`toolDefaults.wall`), else `fallback` (a plain wall).
+ */
+export function useWallDraftThickness(fallback: number): number {
+  const lineKind = useWallLineKindStore((state) => state.lineKind)
+  const seeded = useEditor((state) => state.toolDefaults.wall?.thickness)
+  if (lineKind === 'invisible') return INVISIBLE_WALL_DRAFT_THICKNESS
+  if (lineKind === 'railing') return railingWallDefaults().thickness
+  return typeof seeded === 'number' ? seeded : fallback
+}

package/src/lib/wall-nudge.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from 'bun:test'
+import { WallNode } from '@pascal-app/core'
+import { isWallNudgeKey, WALL_NUDGE_IMPERIAL, wallNudgeDistance } from './wall-nudge'
+
+const outside = { frontSide: 'exterior', backSide: 'interior' } as const
+const wall = (id: string, start: [number, number], end: [number, number]) =>
+  WallNode.parse({ id: `wall_${id}`, start, end, thickness: 0.15, ...outside })
+
+describe('wallNudgeDistance', () => {
+  const moving = wall('moving', [5, 0.3], [8, 0.3])
+
+  test('an arrow across the wall moves it one inch that way', () => {
+    const down = wallNudgeDistance(moving, [0, 1], [moving], WALL_NUDGE_IMPERIAL)
+    const up = wallNudgeDistance(moving, [0, -1], [moving], WALL_NUDGE_IMPERIAL)
+    expect(down).not.toBeNull()
+    expect(up).not.toBeNull()
+    // Signed along the move axis: both land 1 in from where the wall was, opposite ways.
+    const move = (nudge: NonNullable<typeof down>) => nudge.axis[1] * nudge.distance
+    expect(move(down!)).toBeCloseTo(0.0254, 10)
+    expect(move(up!)).toBeCloseTo(-0.0254, 10)
+  })
+
+  test('an arrow along the wall does nothing', () => {
+    expect(wallNudgeDistance(moving, [1, 0], [moving], WALL_NUDGE_IMPERIAL)).toBeNull()
+    expect(wallNudgeDistance(moving, [-1, 0], [moving], WALL_NUDGE_IMPERIAL)).toBeNull()
+  })
+
+  test('stops flush with a parallel outside wall it would pass', () => {
+    const top = wall('top', [0, 0.29], [4, 0.29])
+    const nudge = wallNudgeDistance(moving, [0, -1], [moving, top], WALL_NUDGE_IMPERIAL)!
+    expect(nudge.axis[1] * nudge.distance).toBeCloseTo(-0.01, 10)
+  })
+
+  test('a turned plan still picks the arrow nearest across the wall', () => {
+    const turned = [Math.SQRT1_2, Math.SQRT1_2] as [number, number]
+    const nudge = wallNudgeDistance(moving, turned, [moving], WALL_NUDGE_IMPERIAL)!
+    expect(nudge.axis[1] * nudge.distance).toBeCloseTo(0.0254, 10)
+  })
+})
+
+test('only the four bare arrows nudge', () => {
+  expect(['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'].every(isWallNudgeKey)).toBe(true)
+  expect(isWallNudgeKey('w')).toBe(false)
+})

package/src/lib/wall-nudge.ts

@@ -0,0 +1,131 @@
+/**
+ * Arrow keys nudge the selected wall square to itself in the floor plan: one
+ * inch a press (a centimetre in metric), or less when a parallel wall it lines
+ * up with comes first (`wall-parallel-snap`), so it stops flush. The arrow's
+ * direction on screen picks the way; an arrow along the wall does nothing.
+ * The nudge is the side arrows' push (`commitRoomPush`), so joined walls
+ * follow, jogs and overlaps come out as when the wall is pushed, and each
+ * press is one undo step.
+ */
+
+import {
+  type AnyNodeId,
+  getPerpendicularWallMoveAxis,
+  useScene,
+  type WallNode,
+  type WallPlanPoint,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { commitRoomPush } from './room-handle-drag'
+import { levelSeparatorLines, separatorWallLine } from './separator-lines'
+import { nudgeWallPosition, wallParallelTargets } from './wall-parallel-snap'
+
+/** One nudge in feet and inches, in metres. */
+export const WALL_NUDGE_IMPERIAL = 0.0254
+/** One nudge in metric, in metres. */
+export const WALL_NUDGE_METRIC = 0.01
+
+const ARROW_SCREEN_DIRECTIONS: Record<string, [number, number]> = {
+  ArrowUp: [0, -1],
+  ArrowDown: [0, 1],
+  ArrowLeft: [-1, 0],
+  ArrowRight: [1, 0],
+}
+
+// An arrow within about 67° of the wall's own direction runs along it.
+const MIN_ACROSS = 0.4
+
+/** True for the four bare arrow keys. */
+export function isWallNudgeKey(key: string): boolean {
+  return key in ARROW_SCREEN_DIRECTIONS
+}
+
+/**
+ * The plan direction an arrow points on screen: the shown floor plan's scene
+ * transform, turned or not, maps it back. Null when no floor plan is shown.
+ */
+export function floorplanArrowDirection(key: string): WallPlanPoint | null {
+  const screen = ARROW_SCREEN_DIRECTIONS[key]
+  if (!screen || typeof document === 'undefined') return null
+  const scenes = document.querySelectorAll<SVGGraphicsElement>('[data-floorplan-scene]')
+  for (const scene of scenes) {
+    const rect = scene.ownerSVGElement?.getBoundingClientRect()
+    const ctm = scene.getScreenCTM()
+    if (!ctm || !rect || rect.width === 0 || rect.height === 0) continue
+    const inverse = ctm.inverse()
+    const origin = new DOMPoint(0, 0).matrixTransform(inverse)
+    const tip = new DOMPoint(screen[0], screen[1]).matrixTransform(inverse)
+    const dx = tip.x - origin.x
+    const dz = tip.y - origin.y
+    const length = Math.hypot(dx, dz)
+    if (length > 1e-12) return [dx / length, dz / length]
+  }
+  return null
+}
+
+/**
+ * How far (signed, along the wall's move axis) one nudge of `wall` in plan
+ * direction `direction` goes; null when the direction runs along the wall.
+ */
+export function wallNudgeDistance(
+  wall: WallNode,
+  direction: WallPlanPoint,
+  walls: readonly WallNode[],
+  step: number,
+): { axis: WallPlanPoint; distance: number } | null {
+  const axis = getPerpendicularWallMoveAxis(wall.start, wall.end)
+  if (!axis) return null
+  const across = direction[0] * axis[0] + direction[1] * axis[1]
+  if (Math.abs(across) < MIN_ACROSS) return null
+  const position = wall.start[0] * axis[0] + wall.start[1] * axis[1]
+  const end = nudgeWallPosition(
+    wallParallelTargets(wall, axis, walls),
+    position,
+    Math.sign(across) * step,
+  )
+  return { axis, distance: end - position }
+}
+
+/**
+ * Nudge the one selected wall for an arrow key while the floor plan is shown.
+ * An invisible wall nudges the same way, as a line: it stops flush with the
+ * walls and the other invisible walls, and those joined to it follow.
+ * Returns true when the key was used.
+ */
+export function nudgeSelectedWall(key: string): boolean {
+  const { selectedIds } = useViewer.getState().selection
+  if (selectedIds.length !== 1) return false
+  const nodes = useScene.getState().nodes
+  const selected = nodes[selectedIds[0] as AnyNodeId]
+  if (selected?.type !== 'wall' && selected?.type !== 'separator') return false
+  const direction = floorplanArrowDirection(key)
+  if (!direction) return false
+
+  const walls = Object.values(nodes).filter(
+    (entry): entry is WallNode => entry?.type === 'wall' && entry.parentId === selected.parentId,
+  )
+  const step = useViewer.getState().unit === 'imperial' ? WALL_NUDGE_IMPERIAL : WALL_NUDGE_METRIC
+  const nudge =
+    selected.type === 'wall'
+      ? wallNudgeDistance(selected, direction, walls, step)
+      : wallNudgeDistance(
+          separatorWallLine(selected),
+          direction,
+          [...walls, ...levelSeparatorLines(nodes, selected.parentId, new Set([selected.id]))],
+          step,
+        )
+  if (!nudge) return false
+  commitRoomPush(
+    selected.type === 'wall'
+      ? { wallId: selected.id, t0: 0, t1: 1 }
+      : {
+          wallId: selected.id,
+          t0: 0,
+          t1: 1,
+          separators: [{ separatorId: selected.id, t0: 0, t1: 1 }],
+        },
+    nudge.axis,
+    nudge.distance,
+  )
+  return true
+}

package/src/lib/wall-parallel-snap.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from 'bun:test'
+import { WallNode } from '@pascal-app/core'
+import {
+  nearestWallParallelTarget,
+  nudgeWallPosition,
+  WALL_PARALLEL_SNAP_RADIUS,
+  wallParallelTargets,
+} from './wall-parallel-snap'
+
+const wall = (id: string, start: [number, number], end: [number, number], extra = {}) =>
+  WallNode.parse({ id: `wall_${id}`, start, end, thickness: 0.15, ...extra })
+const outside = { frontSide: 'exterior', backSide: 'interior' } as const
+const DOWN: [number, number] = [0, 1]
+
+describe('wallParallelTargets', () => {
+  test('an outside wall lines up with a parallel outside wall, not a partition', () => {
+    const moving = wall('moving', [5, 0.3], [8, 0.3], outside)
+    const top = wall('top', [0, 0.07], [4, 0.07], outside)
+    const partition = wall('partition', [1, 0.2], [3, 0.2])
+    const side = wall('side', [4, 0.07], [4, 4], outside)
+
+    const targets = wallParallelTargets(moving, DOWN, [moving, top, partition, side])
+
+    expect(targets.map((target) => target.wallId)).toEqual(['wall_top'])
+    expect(targets).toHaveLength(1)
+    expect(targets[0]!.position).toBeCloseTo(0.07)
+    // The guide runs along both walls, on the top wall's outdoor face: frontSide
+    // is the left-normal side, +z for a wall running +x.
+    const [from, to] = [targets[0]!.from, targets[0]!.to]
+    expect([from[0], to[0]]).toEqual([0, 8])
+    expect(from[1]).toBeCloseTo(0.07 + 0.075)
+    expect(to[1]).toBeCloseTo(0.07 + 0.075)
+  })
+
+  test('a partition lines up with every parallel wall', () => {
+    const moving = wall('moving', [1, 2], [3, 2])
+    const top = wall('top', [0, 0], [4, 0], outside)
+    const other = wall('other', [1, 3], [3, 3])
+    const ids = wallParallelTargets(moving, DOWN, [moving, top, other]).map((t) => t.wallId)
+    expect(new Set(ids)).toEqual(new Set(['wall_top', 'wall_other']))
+  })
+
+  test('walls of different thickness line up face to face and centre to centre', () => {
+    const moving = wall('moving', [5, 1], [8, 1], { ...outside, thickness: 0.2 })
+    const top = wall('top', [0, 0], [4, 0], { ...outside, thickness: 0.1 })
+    const positions = wallParallelTargets(moving, DOWN, [top]).map((t) => t.position)
+    // Faces at ±0.05 against ±0.1, and the centres.
+    expect(positions.map((p) => Number(p.toFixed(3))).sort()).toEqual([-0.05, 0, 0.05])
+  })
+
+  test('a reversed or justified wall lines up by its faces', () => {
+    const moving = wall('moving', [8, 1], [5, 1], { ...outside, justification: 'a' })
+    const top = wall('top', [0, 0], [4, 0], outside)
+    const positions = wallParallelTargets(moving, DOWN, [top]).map((t) => t.position)
+    // Justified 'a' on a wall running -x puts its body on the -z side of its
+    // line, so its faces and centre all line up with the top wall's when that
+    // line sits half a thickness below it.
+    expect(positions.map((p) => Number(p.toFixed(3)))).toEqual([0.075])
+  })
+})
+
+describe('nearestWallParallelTarget', () => {
+  test('snaps within the radius and lets go past it', () => {
+    const moving = wall('moving', [5, 0.3], [8, 0.3], outside)
+    const targets = wallParallelTargets(moving, DOWN, [wall('top', [0, 0], [4, 0], outside)])
+    expect(nearestWallParallelTarget(targets, 0.1)?.position).toBeCloseTo(0)
+    expect(nearestWallParallelTarget(targets, WALL_PARALLEL_SNAP_RADIUS + 0.01)).toBeNull()
+  })
+})
+
+describe('nudgeWallPosition', () => {
+  const moving = wall('moving', [5, 0.3], [8, 0.3], outside)
+  const targets = wallParallelTargets(moving, DOWN, [wall('top', [0, 0.29], [4, 0.29], outside)])
+
+  test('stops on a line-up it would pass', () => {
+    expect(nudgeWallPosition(targets, 0.3, -0.0254)).toBeCloseTo(0.29)
+  })
+
+  test('otherwise moves the whole step', () => {
+    expect(nudgeWallPosition(targets, 0.3, 0.0254)).toBeCloseTo(0.3254)
+    expect(nudgeWallPosition(targets, 0.29, -0.0254)).toBeCloseTo(0.2646)
+  })
+})

package/src/lib/wall-parallel-snap.ts

@@ -0,0 +1,176 @@
+/**
+ * Lines a wall that is moving sideways up with the parallel walls around it:
+ * a face onto the face on the same side of another wall, or its body centre
+ * onto theirs. An outside wall broken up by partitions moves one piece at a
+ * time, so each piece can be pulled back flush with the rest of the outside.
+ *
+ * A wall with an outdoor face lines up only with other outside walls; any
+ * other wall lines up with every wall on its level. The 2D and 3D wall moves
+ * snap through here, and the arrow-key nudge stops on these positions.
+ */
+
+import {
+  getWallFaceOffsets,
+  isCurvedWall,
+  type WallNode,
+  type WallPlanPoint,
+} from '@pascal-app/core'
+import useAlignmentGuides from '../store/use-alignment-guides'
+
+/** How near (metres) a moving wall comes to lining up before it snaps there. */
+export const WALL_PARALLEL_SNAP_RADIUS = 0.15
+
+// Walls within about 1° of each other count as parallel.
+const PARALLEL_TOLERANCE = Math.sin(Math.PI / 180)
+const SAME_POSITION = 1e-6
+
+type MovingWall = Pick<
+  WallNode,
+  'id' | 'start' | 'end' | 'thickness' | 'justification' | 'frontSide' | 'backSide'
+> &
+  Partial<Pick<WallNode, 'curveOffset'>>
+
+/**
+ * A position where the moving wall lines up with another: `position` is where
+ * its reference line sits along the move axis, `from` → `to` the shared face
+ * or centre line, drawn along both walls.
+ */
+export type WallParallelTarget = {
+  position: number
+  wallId: string
+  from: WallPlanPoint
+  to: WallPlanPoint
+}
+
+function isOutsideWall(wall: Pick<WallNode, 'frontSide' | 'backSide'>): boolean {
+  return wall.frontSide === 'exterior' || wall.backSide === 'exterior'
+}
+
+function direction(wall: Pick<WallNode, 'start' | 'end'>): WallPlanPoint | null {
+  const dx = wall.end[0] - wall.start[0]
+  const dz = wall.end[1] - wall.start[1]
+  const length = Math.hypot(dx, dz)
+  return length > 1e-9 ? [dx / length, dz / length] : null
+}
+
+const dot = (a: readonly [number, number], b: readonly [number, number]) =>
+  a[0] * b[0] + a[1] * b[1]
+
+// Which way the wall's left normal (-dy, dx) runs along `axis`.
+function normalSign(dir: WallPlanPoint, axis: WallPlanPoint): number {
+  return Math.sign(dot([-dir[1], dir[0]], axis)) || 1
+}
+
+/**
+ * The wall's faces and body centre along `axis`, relative to its reference
+ * line: the face on the axis's positive side, the other face, the centre.
+ */
+function sidePlanes(wall: MovingWall, dir: WallPlanPoint, axis: WallPlanPoint) {
+  const sign = normalSign(dir, axis)
+  const { a, b } = getWallFaceOffsets(wall)
+  const high = Math.max(a * sign, b * sign)
+  const low = Math.min(a * sign, b * sign)
+  return [high, low, (high + low) / 2] as const
+}
+
+/**
+ * The order to try a wall's planes in, so the guide of planes that coincide
+ * is drawn on its outdoor face (frontSide is the left-normal side), else on
+ * its centre.
+ */
+function planeOrder(wall: MovingWall, dir: WallPlanPoint, axis: WallPlanPoint): number[] {
+  const outdoor = wall.frontSide === 'exterior' ? 1 : wall.backSide === 'exterior' ? -1 : 0
+  const outward = outdoor * normalSign(dir, axis)
+  return outward > 0 ? [0, 1, 2] : outward < 0 ? [1, 0, 2] : [2, 0, 1]
+}
+
+/**
+ * Every position along `axis` (a unit vector square to the wall) where `wall`
+ * lines up with a parallel wall in `walls`.
+ */
+export function wallParallelTargets(
+  wall: MovingWall,
+  axis: WallPlanPoint,
+  walls: readonly WallNode[],
+): WallParallelTarget[] {
+  const dir = direction(wall)
+  if (!dir || isCurvedWall(wall)) return []
+  const own = sidePlanes(wall, dir, axis)
+  const outsideOnly = isOutsideWall(wall)
+  const ownSpan = [dot(wall.start, dir), dot(wall.end, dir)]
+  const targets: WallParallelTarget[] = []
+
+  for (const other of walls) {
+    if (other.id === wall.id || isCurvedWall(other)) continue
+    if (outsideOnly && !isOutsideWall(other)) continue
+    const otherDir = direction(other)
+    if (!otherDir || Math.abs(otherDir[0] * dir[1] - otherDir[1] * dir[0]) > PARALLEL_TOLERANCE) {
+      continue
+    }
+    const line = dot(other.start, axis)
+    const planes = sidePlanes(other, otherDir, axis)
+    const along = [...ownSpan, dot(other.start, dir), dot(other.end, dir)]
+    const lo = Math.min(...along)
+    const hi = Math.max(...along)
+    const seen: number[] = []
+    for (const index of planeOrder(other, otherDir, axis)) {
+      const shared = line + planes[index]!
+      const position = shared - own[index]!
+      if (seen.some((value) => Math.abs(value - position) < SAME_POSITION)) continue
+      seen.push(position)
+      targets.push({
+        position,
+        wallId: other.id,
+        from: [dir[0] * lo + axis[0] * shared, dir[1] * lo + axis[1] * shared],
+        to: [dir[0] * hi + axis[0] * shared, dir[1] * hi + axis[1] * shared],
+      })
+    }
+  }
+  return targets
+}
+
+/** The target nearest `position`, if one is within `radius`. */
+export function nearestWallParallelTarget(
+  targets: readonly WallParallelTarget[],
+  position: number,
+  radius = WALL_PARALLEL_SNAP_RADIUS,
+): WallParallelTarget | null {
+  let best: WallParallelTarget | null = null
+  for (const target of targets) {
+    const gap = Math.abs(target.position - position)
+    if (gap > radius) continue
+    if (!best || gap < Math.abs(best.position - position)) best = target
+  }
+  return best
+}
+
+/**
+ * Where a nudge of `step` (signed, along the axis) from `position` ends: the
+ * full step, or the first line-up it passes on the way.
+ */
+export function nudgeWallPosition(
+  targets: readonly WallParallelTarget[],
+  position: number,
+  step: number,
+): number {
+  let end = position + step
+  for (const target of targets) {
+    const travel = (target.position - position) * Math.sign(step)
+    if (travel > SAME_POSITION && travel < Math.abs(step) - SAME_POSITION) {
+      if (Math.abs(target.position - position) < Math.abs(end - position)) end = target.position
+    }
+  }
+  return end
+}
+
+/** Show the line a moving wall has snapped onto (null clears it). */
+export function publishWallParallelGuide(target: WallParallelTarget | null): void {
+  if (!target) {
+    useAlignmentGuides.getState().clear()
+    return
+  }
+  useAlignmentGuides.getState().setDraft({
+    lines: [{ kind: 'alignment', from: target.from, to: target.to }],
+    intersections: [],
+  })
+}

package/src/lib/wall-placement-pointer.test.ts

@@ -4,6 +4,7 @@ import {
   createWallPointerTracker,
   wallPointerInParent,
   wallSideAtPointer,
+  wallSideOfPlanPoint,
 } from './wall-placement-pointer'
 
 test('keeps the grab offset across a pointer gap on the original face', () => {
@@ -40,3 +41,25 @@ test('reads the pointer in the rotated wall parent and identifies its face', ()
   expect(local[1]).toBeCloseTo(3)
   expect(wallSideAtPointer(local)).toBe('back')
 })
+
+test('a plan point reads the wall face it is on, as a 3D hover does', () => {
+  // Along +X the frame's +Z (front) is the plan's +Z side.
+  const wall = {
+    start: [0, 0] as [number, number],
+    end: [4, 0] as [number, number],
+    thickness: 0.2,
+  }
+  expect(wallSideOfPlanPoint(wall, [2, 0.3])).toBe('front')
+  expect(wallSideOfPlanPoint(wall, [2, -0.3])).toBe('back')
+  // Drawn the other way, the same point is on its back.
+  expect(
+    wallSideOfPlanPoint(
+      { ...wall, start: [4, 0] as [number, number], end: [0, 0] as [number, number] },
+      [2, 0.3],
+    ),
+  ).toBe('back')
+  // A justified wall splits at its body's middle, not its reference line.
+  const justified = { ...wall, justification: 'a' as const }
+  expect(wallSideOfPlanPoint(justified, [2, 0.05])).toBe('back')
+  expect(wallSideOfPlanPoint(justified, [2, 0.15])).toBe('front')
+})