@pascal-app/editor 1.0.6 → 1.1.0

package/src/components/tools/site/terrain-brush-cursor.tsx

@@ -10,7 +10,6 @@ import {
   useLiveTerrain,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
-import { Html } from '@react-three/drei'
 import { useFrame, useThree } from '@react-three/fiber'
 import { type MutableRefObject, useEffect, useMemo, useRef } from 'react'
 import {
@@ -25,6 +24,7 @@ import { EDITOR_LAYER } from '../../../lib/constants'
 import { sculptFieldForSite, terrainPointInsideSite } from '../../../lib/terrain-sculpt'
 import { brushRingColor } from '../../../lib/terrain-verb-color'
 import useEditor from '../../../store/use-editor'
+import { Html } from '../../editor/localized-html'
 import { formatMeasurement } from '../../editor/measurement-pill'
 
 /** Segments in the cursor ring. 64 reads as a circle at any usable brush size. */

package/src/components/tools/tool-manager.tsx

@@ -41,7 +41,6 @@ import { FloorRegionControls3D } from '../editor/floor-region-controls'
 import { OpenWallEnds3DLayer } from '../editor/open-wall-ends-3d-layer'
 import { OpeningGuides3DLayer } from '../editor/opening-guides-3d-layer'
 import { WallSnapBeaconLayer } from '../editor/wall-snap-beacon-layer'
-import { ElevatorTool } from './elevator/elevator-tool'
 import { MoveTool } from './item/move-tool'
 import { WallPaintRegionTool } from './paint-region/wall-paint-region-tool'
 import { RegistryToolProvider } from './registry-tool-context'
@@ -305,21 +304,6 @@ export const ToolManager: React.FC = () => {
   const handlePlacedNodeSelected = (nodeId: AnyNodeId) => {
     setSelection({ selectedIds: [nodeId] })
   }
-  const handlePlacedElevatorSelected = (
-    nodeId: AnyNodeId,
-    elevatorBuildingId: BuildingNode['id'],
-  ) => {
-    // Preserve the active level. `setSelection`'s hierarchy guard nulls
-    // `levelId` whenever `buildingId` is passed without an explicit
-    // `levelId` — which deselected the current floor plan the moment an
-    // elevator was placed. Pass the current level through so the floor
-    // plan stays selected.
-    setSelection({
-      buildingId: elevatorBuildingId,
-      levelId: activeLevelId ?? null,
-      selectedIds: [nodeId],
-    })
-  }
 
   return (
     <RegistryToolProvider value={registryToolContext}>
@@ -463,14 +447,7 @@ export const ToolManager: React.FC = () => {
             <RegistryToolComponent />
           </Suspense>
         )}
-        {!movingNode && !useRegistryTool && showBuildTool && tool === 'elevator' && (
-          <ElevatorTool
-            buildingId={buildingId as BuildingNode['id'] | null}
-            levelId={activeLevelId ?? null}
-            onPlaced={handlePlacedElevatorSelected}
-          />
-        )}
-        {!movingNode && BuildToolComponent && tool !== 'elevator' ? <BuildToolComponent /> : null}
+        {!movingNode && BuildToolComponent ? <BuildToolComponent /> : null}
         {/* Figma-style alignment guides published by the move / placement
             tools above. Lives inside the building-local group so the
             building-local guide coords render at the right world position. */}

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

@@ -9,6 +9,7 @@ import {
   createTerrainField,
   DoorNode as DoorSchema,
   encodeTerrainField,
+  findOpenWallEnds,
   flattenPatch,
   GROUND_SUPPORT_ID,
   getFloorPlacedElevation,
@@ -19,6 +20,7 @@ import {
   resolveTerrainWallConstructionOptions,
   runAsSingleSceneHistoryStep,
   SlabNode,
+  snapWorldXZToBuildingLocal,
   spatialGridManager,
   useScene,
   type WallNode,
@@ -30,11 +32,15 @@ import {
   migrateRoomZones,
 } from '@pascal-app/core/scene-migrations'
 import { useViewer } from '@pascal-app/viewer'
-import useEditor from '../../../store/use-editor'
+import type { SnappingMode } from '../../../lib/snapping-mode'
+import { snapBuildingLocalToWorldGrid } from '../../../lib/world-grid-snap'
+import useEditor, { isAngleSnapActive, isMagneticSnapActive } from '../../../store/use-editor'
 import useInteractionScope from '../../../store/use-interaction-scope'
 import {
   createWallOnCurrentLevel,
+  getSegmentGridStep,
   resolveEndpointWallSplit,
+  snapWallDraftPoint,
   snapWallDraftPointDetailed,
 } from './wall-drafting'
 import type { WallPlanPoint } from './wall-snap-geometry'
@@ -758,27 +764,64 @@ describe('createWallOnCurrentLevel', () => {
     expect(levelWalls()).toHaveLength(2)
   })
 
-  test('genuine mid-wall endpoint still splits the host (T junction)', () => {
-    const created = createWallOnCurrentLevel([2, 2], [2, 0])
+  test.each(['grid', 'lines', 'angles', 'off'] as const)(
+    '%s drafting splits the host at a mid-wall junction',
+    (mode) => {
+      useEditor.getState().setSnappingMode('wall', mode)
+      const created = createWallOnCurrentLevel([2, 2], [2, 0])
+
+      expect(created?.end).toEqual([2, 0])
+      expect(useScene.getState().nodes['wall_a' as AnyNodeId]).toBeUndefined()
+      expect(
+        levelWalls()
+          .filter((wall) => wall.id !== created?.id)
+          .map(({ start, end }) => [start, end]),
+      ).toEqual([
+        [
+          [0, 0],
+          [2, 0],
+        ],
+        [
+          [2, 0],
+          [4, 0],
+        ],
+      ])
+    },
+  )
 
-    expect(created?.end).toEqual([2, 0])
-    expect(useScene.getState().nodes['wall_a' as AnyNodeId]).toBeUndefined()
-    const walls = levelWalls()
-    expect(walls).toHaveLength(3)
-    expect(
-      walls.some((wall) => wall.start[0] === 0 && wall.end[0] === 2 && wall.end[1] === 0),
-    ).toBe(true)
-    expect(
-      walls.some((wall) => wall.start[0] === 2 && wall.start[1] === 0 && wall.end[0] === 4),
-    ).toBe(true)
+  test('a wall drawn exactly over one built another way takes its place', () => {
+    // The seed wall is plain; the wall tool draws a thicker one.
+    const previousDefaults = useEditor.getState().toolDefaults
+    useEditor.setState({ toolDefaults: { ...previousDefaults, wall: { thickness: 0.3 } } } as never)
+    try {
+      const drawn = createWallOnCurrentLevel([0, 0], [4, 0])
+      expect(drawn).not.toBeNull()
+      expect(useScene.getState().nodes['wall_a' as AnyNodeId]).toBeUndefined()
+      expect(levelWalls().map((wall) => wall.id)).toEqual([drawn!.id])
+    } finally {
+      useEditor.setState({ toolDefaults: previousDefaults } as never)
+    }
   })
 
-  test('exact duplicate segment is rejected', () => {
+  test('a wall drawn exactly over one built the same is refused', () => {
     expect(createWallOnCurrentLevel([0, 0], [4, 0])).toBeNull()
     expect(levelWalls()).toHaveLength(1)
   })
 
-  test('grid mode: endpoint resolved onto a wall body still splits the host', () => {
+  test('a wall drawn on along part of another takes that stretch over', () => {
+    const drawn = createWallOnCurrentLevel([2, 0], [6, 0])
+    expect(drawn).not.toBeNull()
+    const walls = levelWalls()
+    // The seed wall keeps [0, 2]; nothing else runs along [2, 4].
+    expect(walls).toHaveLength(2)
+    const seed = walls.find((wall) => wall.id !== drawn!.id)!
+    expect([seed.start, seed.end]).toEqual([
+      [0, 0],
+      [2, 0],
+    ])
+  })
+
+  test('grid mode: endpoint resolved onto a wall body splits its host', () => {
     useEditor.getState().setSnappingMode('wall', 'grid')
 
     const created = createWallOnCurrentLevel([2, 2], [2, 0])
@@ -798,7 +841,7 @@ describe('createWallOnCurrentLevel', () => {
     expect(levelWalls()).toHaveLength(2)
   })
 
-  test('mid-span split migrates the host attachments to the covering half', () => {
+  test('a T into a wall rehosts its door at the same position', () => {
     const door = DoorSchema.parse({
       position: [1, 1.05, 0],
       parentId: 'wall_a',
@@ -809,12 +852,12 @@ describe('createWallOnCurrentLevel', () => {
     const created = createWallOnCurrentLevel([2, 2], [2, 0])
 
     expect(created?.end).toEqual([2, 0])
-    const walls = levelWalls()
-    const firstHalf = walls.find((wall) => wall.start[0] === 0 && wall.end[0] === 2)
-    expect(firstHalf).toBeDefined()
-    const migratedDoor = useScene.getState().nodes[door.id as AnyNodeId]
-    expect(migratedDoor?.parentId).toBe(firstHalf?.id)
-    expect(firstHalf?.children).toContain(door.id)
+    const kept = useScene.getState().nodes[door.id as AnyNodeId] as DoorSchema
+    expect(kept.parentId).not.toBe('wall_a')
+    expect(kept.position[0]).toBe(1)
+    expect((useScene.getState().nodes[kept.parentId as AnyNodeId] as WallNode).children).toContain(
+      door.id,
+    )
   })
 
   test('a splitting commit lands as a single undo step', () => {
@@ -826,7 +869,7 @@ describe('createWallOnCurrentLevel', () => {
     expect(useScene.temporal.getState().pastStates.length - before).toBe(1)
   })
 
-  test('a crossing splits both the host and the inserted wall in one undo step', () => {
+  test('a crossing splits both walls in one undo step', () => {
     const before = useScene.temporal.getState().pastStates.length
 
     const created = createWallOnCurrentLevel([2, -2], [2, 2])
@@ -1095,4 +1138,237 @@ describe('snapWallDraftPointDetailed', () => {
     expect(freed.point).toEqual([2, 0])
     expect(freed.snap).toBeNull()
   })
+
+  test('an end aimed into an L corner block joins the corner and reads as one', () => {
+    const south = { ...makeWall([0, 0], [4, 0], 'wall_south'), thickness: 0.2 }
+    const west = { ...makeWall([0, 4], [0, 0], 'wall_west'), thickness: 0.2 }
+    const result = snapWallDraftPointDetailed({
+      point: [0.08, 0.08],
+      walls: [south, west],
+      start: [2, 3],
+      magnetic: false,
+      step: 0,
+      captureWallBodies: true,
+    })
+    expect(result.point).toEqual([0, 0])
+    expect(result.snap).toBe('endpoint')
+    expect(result.targetWallIds).toEqual(['wall_south', 'wall_west'])
+  })
+
+  // The 3D tool snaps to the floor below as a reference but can't join it: an
+  // end by a lower wall's face stays put, while its corner still snaps.
+  test('walls left out of bodyWalls never capture an end, but still snap corners', () => {
+    const lower = { ...makeWall([0, 0.4], [4, 0.4], 'wall_lower'), thickness: 0.2 }
+    const snap = (point: WallPlanPoint, bodyWalls?: WallNode[]) =>
+      snapWallDraftPointDetailed({
+        point,
+        walls: [lower],
+        start: [1, 3],
+        magnetic: false,
+        step: 0,
+        captureWallBodies: true,
+        bodyWalls,
+      })
+
+    const captured = snap([1, 0.5])
+    expect(captured.snap).toBe('wall')
+    expect(captured.point[1]).toBeCloseTo(0.4, 12)
+
+    const free = snap([1, 0.5], [])
+    expect(free.point).toEqual([1, 0.5])
+    expect(free.snap).toBeNull()
+
+    const corner = snap([0.02, 0.42], [])
+    expect(corner.point).toEqual([0, 0.4])
+    expect(corner.snap).toBe('endpoint')
+  })
 })
+
+// The site planner sets a house on its lot turned and offset. Its walls are
+// drawn square to the house, in building-local metres. An interior wall drawn
+// across it has to meet both exterior walls exactly and stay square to the
+// house however the building is turned, in 3D and on the plan alike.
+const HOUSE_BUILDING_ID = 'building_lot'
+// A 30' × 24' house of 8" walls, 2' × 1' off the building origin, so no wall
+// line or face lies on the 0.5 m lattice.
+const HOUSE_MIN: WallPlanPoint = [0.6096, 0.3048]
+const HOUSE_MAX: WallPlanPoint = [9.7536, 7.62]
+const EXTERIOR_THICKNESS = 0.2032
+// Where a builder aims an interior wall's end: just inside the exterior
+// wall's interior face (1.18" off it).
+const FACE_AIM = EXTERIOR_THICKNESS / 2 + 0.03
+
+const BUILDING_POSES: Array<{
+  label: string
+  yaw: number
+  position: [number, number, number]
+}> = [
+  { label: 'an unturned building at the origin', yaw: 0, position: [0, 0, 0] },
+  {
+    label: 'a building turned 17° and offset on its lot',
+    yaw: (17 * Math.PI) / 180,
+    position: [12.37, 0, -8.91],
+  },
+]
+
+function seedHouse({ yaw, position }: { yaw: number; position: [number, number, number] }) {
+  const [x0, z0] = HOUSE_MIN
+  const [x1, z1] = HOUSE_MAX
+  const walls = [
+    makeWall([x0, z0], [x1, z0], 'wall_south'),
+    makeWall([x1, z0], [x1, z1], 'wall_east'),
+    makeWall([x1, z1], [x0, z1], 'wall_north'),
+    makeWall([x0, z1], [x0, z0], 'wall_west'),
+  ].map((wall) => ({ ...wall, thickness: EXTERIOR_THICKNESS }))
+  const building = BuildingNode.parse({
+    id: HOUSE_BUILDING_ID,
+    position,
+    rotation: [0, yaw, 0],
+    children: [LEVEL_ID],
+  })
+  const level = LevelSchema.parse({ id: LEVEL_ID, parentId: building.id, level: 0, height: 2.5 })
+  useScene.setState({
+    nodes: Object.fromEntries([
+      [building.id, building],
+      [level.id, { ...level, children: walls.map((wall) => wall.id) }],
+      ...walls.map((wall) => [wall.id, wall] as const),
+    ]),
+    rootNodeIds: [building.id],
+    dirtyNodes: new Set(),
+    collections: {},
+  } as never)
+  useViewer.setState({
+    selection: {
+      buildingId: HOUSE_BUILDING_ID,
+      levelId: LEVEL_ID,
+      zoneId: null,
+      selectedIds: [],
+    },
+  } as never)
+}
+
+for (const pose of BUILDING_POSES) {
+  describe(`an interior wall drawn across a house in ${pose.label}`, () => {
+    const [, z0] = HOUSE_MIN
+    const [, z1] = HOUSE_MAX
+
+    beforeEach(() => {
+      useEditor.getState().setGridSnapStep(0.5)
+      // A reshaping-endpoint scope resolves to the 'wall' snap context
+      // without the node registry, as in `createWallOnCurrentLevel` above.
+      useInteractionScope
+        .getState()
+        .begin({ kind: 'reshaping', nodeId: 'wall_south', reshape: 'endpoint', driver: 'tool' })
+      seedHouse(pose)
+      useScene.temporal.getState().clear()
+      useScene.temporal.getState().resume()
+    })
+
+    afterEach(() => {
+      useEditor.getState().setSnappingMode('wall', 'grid')
+    })
+
+    const setMode = (mode: SnappingMode) => useEditor.getState().setSnappingMode('wall', mode)
+
+    // The cursor as a grid event hands it over: a hit on the world plane,
+    // taken into the building's frame.
+    const cursorAt = (local: WallPlanPoint): WallPlanPoint => {
+      const cos = Math.cos(pose.yaw)
+      const sin = Math.sin(pose.yaw)
+      const worldX = pose.position[0] + local[0] * cos + local[1] * sin
+      const worldZ = pose.position[2] - local[0] * sin + local[1] * cos
+      return snapWorldXZToBuildingLocal(worldX, worldZ, pose.position, pose.yaw, 0).local
+    }
+
+    // The 3D wall tool's snap call.
+    const snapIn3d = (point: WallPlanPoint, start?: WallPlanPoint, captureWallBodies = true) =>
+      snapWallDraftPointDetailed({
+        point,
+        walls: levelWalls(),
+        start,
+        angleSnap: start !== undefined && isAngleSnapActive(),
+        magnetic: isMagneticSnapActive(),
+        captureWallBodies,
+      })
+
+    // The plan's click: the same cursor through the plan's grid callback.
+    const snapOnPlan = (point: WallPlanPoint, start?: WallPlanPoint) =>
+      snapWallDraftPoint({
+        point,
+        walls: levelWalls(),
+        start,
+        angleSnap: start !== undefined && isAngleSnapActive(),
+        magnetic: isMagneticSnapActive(),
+        gridSnap: (p) => snapBuildingLocalToWorldGrid(p, getSegmentGridStep()),
+        captureWallBodies: true,
+      })
+
+    const partitionOpenEnds = (partition: WallNode) =>
+      findOpenWallEnds(useScene.getState().nodes, LEVEL_ID).filter(
+        (end) => end.wallId === partition.id,
+      )
+
+    test('grid: both ends land on the exterior walls, square to the house, with no gap', () => {
+      setMode('grid')
+      const startAim = cursorAt([4.2, z0 + FACE_AIM])
+      const start = snapIn3d(startAim)
+      expect(start.snap).toBe('wall')
+      expect(start.targetWallIds).toEqual(['wall_south'])
+      expect(start.point[0]).toBeCloseTo(4, 9)
+      expect(start.point[1]).toBeCloseTo(z0, 9)
+
+      // The cursor drifts a little sideways on its way across the house.
+      const endAim = cursorAt([4.1, z1 - FACE_AIM])
+      const end = snapIn3d(endAim, start.point)
+      expect(end.snap).toBe('wall')
+      expect(end.targetWallIds).toEqual(['wall_north'])
+      expect(end.point[0]).toBeCloseTo(start.point[0], 9)
+      expect(end.point[1]).toBeCloseTo(z1, 9)
+
+      // The plan snaps the same cursor to the same points.
+      expect(snapOnPlan(startAim)).toEqual(start.point)
+      expect(snapOnPlan(endAim, start.point)).toEqual(end.point)
+
+      const partition = createWallOnCurrentLevel(start.point, end.point)
+      expect(partition).not.toBeNull()
+      expect(partitionOpenEnds(partition!)).toEqual([])
+    })
+
+    test('ortho holds the wall square to the house and lands it on the far wall', () => {
+      setMode('angles')
+      const startAim = cursorAt([4.2, z0 + FACE_AIM])
+      const start = snapIn3d(startAim)
+      expect(start.point[0]).toBeCloseTo(4.2, 9)
+      expect(start.point[1]).toBeCloseTo(z0, 9)
+
+      // 4° off square: the 15° lock squares it to the house.
+      const endAim = cursorAt([3.7, z1 - FACE_AIM])
+      const end = snapIn3d(endAim, start.point)
+      expect(end.snap).toBe('wall')
+      expect(end.point[0]).toBeCloseTo(start.point[0], 9)
+      expect(end.point[1]).toBeCloseTo(z1, 9)
+
+      const onPlan = snapOnPlan(endAim, start.point)
+      expect(onPlan[0]).toBeCloseTo(end.point[0], 9)
+      expect(onPlan[1]).toBeCloseTo(end.point[1], 9)
+
+      const partition = createWallOnCurrentLevel(start.point, end.point)
+      expect(partition).not.toBeNull()
+      expect(partitionOpenEnds(partition!)).toEqual([])
+    })
+
+    test('without the body snap the lattice stops the end short of the face: an open gap', () => {
+      setMode('grid')
+      const start = snapIn3d(cursorAt([4.2, z0 + FACE_AIM]))
+      const end = snapIn3d(cursorAt([4.1, z1 - FACE_AIM]), start.point, false)
+      // The lattice line under the cursor, 0.72" short of the north wall's face.
+      expect(end.snap).toBeNull()
+      expect(end.point[1]).toBeCloseTo(7.5, 9)
+
+      const partition = createWallOnCurrentLevel(start.point, end.point)
+      const [open] = partitionOpenEnds(partition!)
+      expect(open?.reason).toBe('gap')
+      expect(open?.gap).toBeCloseTo(z1 - EXTERIOR_THICKNESS / 2 - 7.5, 3)
+    })
+  })
+}

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

@@ -1,21 +1,30 @@
 import {
   type AnyNodeId,
   DEFAULT_ANGLE_STEP,
+  finishWallEdit,
+  generateId,
+  planSeparatorInsertion,
   planWallInsertion,
   planWallSplitAtPoint,
+  railingWallDefaults,
   resolveWallConstruction,
   runAsSingleSceneHistoryStep,
+  type SeparatorNode,
+  sameWallConstruction,
   snapPointAlongAngleRay,
   useScene,
   type WallConstructionOptions,
   type WallNode,
+  wallsRunAlong,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { sfxEmitter } from '../../../lib/sfx-bus'
 import { resolveSnapFlags } from '../../../lib/snapping-mode'
+import { getWallLineKind } from '../../../lib/wall-draw-variant'
 import useEditor, { getActiveSnappingMode, isMagneticSnapActive } from '../../../store/use-editor'
 import {
   distanceSquared,
+  findWallBodySnapTarget,
   findWallSnapTarget,
   findWallSpecialPointSnap,
   WALL_CONNECT_SNAP_RADIUS,
@@ -109,14 +118,30 @@ type SnapWallDraftArgs = {
    */
   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`.
+   * Optional grid-snap override, in the caller's plan frame. When omitted,
+   * falls back to the building-local grid at `step` — the lattice the wall
+   * tools draft on, square to the house however the building is turned.
    */
   gridSnap?: (point: WallPlanPoint) => WallPlanPoint
   /** Optional magnetic snap radii. Omitted means wall tools keep their defaults. */
   snapRadii?: WallSnapRadii
+  /**
+   * The point is a wall end (drawn or dragged): in the non-magnetic modes an
+   * end aimed into another wall's drawn body, or within the connect radius of
+   * either face, lands on that wall's reference line — where the wall
+   * topology T-joins it — ahead of the grid / angle placement, keeping the
+   * segment's direction from `start` (see `findWallBodySnapTarget`). Without
+   * it the grid quantises an end aimed at a face to the nearest lattice point,
+   * a fraction short of the face, and the end stays open with a gap.
+   */
+  captureWallBodies?: boolean
+  /**
+   * The walls `captureWallBodies` may join an end into; `walls` when omitted.
+   * A body capture T-joins the wall, so a caller that adds reference walls it
+   * can't join (the floor below) keeps them out of this list while they still
+   * serve the corner and edge snaps.
+   */
+  bodyWalls?: WallNode[]
 }
 
 export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSnapResult {
@@ -131,6 +156,8 @@ export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSn
     magnetic = true,
     gridSnap,
     snapRadii,
+    captureWallBodies = false,
+    bodyWalls = walls,
   } = args
 
   if (bypassSnap) return { point, snap: null, targetWallIds: [] }
@@ -144,9 +171,8 @@ export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSn
   }
 
   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.
+  // The angle path snaps the distance ALONG the 15° ray from `start`, so the
+  // `gridSnap` override only applies when the angle lock is off.
   const basePoint: WallPlanPoint =
     start && angleSnap
       ? [...snapPointAlongAngleRay(start, point, DEFAULT_ANGLE_STEP, step)]
@@ -182,6 +208,30 @@ export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSn
   }
   const connectSpecial = findWallSpecialPointSnap(basePoint, walls, ignoreWallIds, connectRadii)
   if (connectSpecial) return connectSpecial
+  // A wall end aimed into a wall's body joins it, whichever lattice point or
+  // ray station the mode picked near its face.
+  const bodySnap = captureWallBodies
+    ? findWallBodySnapTarget(point, bodyWalls, {
+        ignoreWallIds,
+        placed: basePoint,
+        start,
+        margin: WALL_CONNECT_SNAP_RADIUS,
+      })
+    : null
+  if (bodySnap) {
+    // An end aimed into a corner block joins the corner, and reads as one.
+    const atCorner = bodyWalls.some(
+      (wall) =>
+        !ignoreWallIds?.includes(wall.id) &&
+        (distanceSquared(bodySnap, wall.start) <= 1e-12 ||
+          distanceSquared(bodySnap, wall.end) <= 1e-12),
+    )
+    return {
+      point: bodySnap,
+      snap: atCorner ? 'endpoint' : 'wall',
+      targetWallIds: wallIdsAtSnapPoint(bodySnap, walls, ignoreWallIds),
+    }
+  }
   const connectWall = findWallSnapTarget(basePoint, walls, {
     ignoreWallIds,
     radius: WALL_CONNECT_SNAP_RADIUS,
@@ -205,6 +255,36 @@ export function isSegmentLongEnough(start: WallPlanPoint, end: WallPlanPoint): b
   return distanceSquared(start, end) >= WALL_MIN_LENGTH * WALL_MIN_LENGTH
 }
 
+/**
+ * An invisible wall drawn `start` → `end` on the current level (the Walls variant's Invisible, a room
+ * divider): room separators, each end joined to a wall it lands on and broken
+ * either side of a wall it crosses (`planSeparatorInsertion`), as one undo step. Rooms close on
+ * it; a room it closes off outside the house becomes a porch. The last piece, for the run to go
+ * on from its end; null when it would be too short.
+ */
+export function createInvisibleWallOnCurrentLevel(
+  start: WallPlanPoint,
+  end: WallPlanPoint,
+): SeparatorNode | null {
+  const currentLevelId = useViewer.getState().selection.levelId
+  const { nodes, applyNodeChanges } = useScene.getState()
+  if (!(currentLevelId && isSegmentLongEnough(start, end))) return null
+  const joinRadius = isMagneticSnapActive() ? WALL_JOIN_SNAP_RADIUS : WALL_CONNECT_SNAP_RADIUS
+  return runAsSingleSceneHistoryStep(useScene, () => {
+    const plan = planSeparatorInsertion(nodes, {
+      levelId: currentLevelId as AnyNodeId,
+      start,
+      end,
+      joinRadius,
+      mintId: () => generateId('separator'),
+    })
+    if (!plan) return null
+    applyNodeChanges(plan.changes)
+    sfxEmitter.emit('sfx:structure-build')
+    return plan.separators.at(-1) ?? null
+  })
+}
+
 export function createWallOnCurrentLevel(
   start: WallPlanPoint,
   end: WallPlanPoint,
@@ -220,13 +300,33 @@ export function createWallOnCurrentLevel(
   const joinRadius = isMagneticSnapActive() ? WALL_JOIN_SNAP_RADIUS : WALL_CONNECT_SNAP_RADIUS
 
   return runAsSingleSceneHistoryStep(useScene, () => {
-    const result = planWallInsertion(nodes, {
+    // The Walls variant's Railing draws railings: a guard of their own.
+    const insertion = {
       levelId: currentLevelId as AnyNodeId,
       start,
       end,
       joinRadius,
-      wallDefaults: useEditor.getState().toolDefaults.wall ?? {},
-    })
+      wallDefaults:
+        getWallLineKind() === 'railing'
+          ? railingWallDefaults()
+          : (useEditor.getState().toolDefaults.wall ?? {}),
+    }
+    let result = planWallInsertion(nodes, insertion)
+    if (!result.ok && result.reason === 'covered-existing-wall') {
+      // Drawn over walls built another way (an outside wall over an inside
+      // jog), the new wall takes their stretch over; over walls built the
+      // same, it would change nothing, so it stays refused.
+      const replacing = planWallInsertion(nodes, { ...insertion, replaceCovered: true })
+      if (
+        replacing.ok &&
+        replacing.plan.insertedWalls.some((wall) =>
+          wallsRunAlong(nodes, { ...wall, parentId: currentLevelId } as WallNode).some(
+            (covered) => !sameWallConstruction(covered, wall),
+          ),
+        )
+      )
+        result = replacing
+    }
     if (!result.ok) return null
     const { plan } = result
 
@@ -237,20 +337,28 @@ export function createWallOnCurrentLevel(
     const sourceAlreadyUpdated = sourceUpdate
       ? plan.changes.update.some((operation) => operation.id === sourceUpdate.id)
       : false
-    applyNodeChanges({
-      ...plan.changes,
-      update: plan.changes.update
-        .map((operation) =>
-          sourceUpdate?.id === operation.id
-            ? { ...operation, data: { ...operation.data, ...sourceUpdate.data } }
-            : operation,
-        )
-        .concat(sourceUpdate && !sourceAlreadyUpdated ? [sourceUpdate] : []),
-      create: plan.changes.create.map((operation) => ({
-        ...operation,
-        node: finalizedWallsById.get(operation.node.id as WallNode['id']) ?? operation.node,
-      })),
-    })
+    // A wall drawn along part of a parallel wall takes that stretch over, so
+    // drawing on from a wall never doubles the one it runs along.
+    applyNodeChanges(
+      finishWallEdit(
+        nodes,
+        {
+          ...plan.changes,
+          update: plan.changes.update
+            .map((operation) =>
+              sourceUpdate?.id === operation.id
+                ? { ...operation, data: { ...operation.data, ...sourceUpdate.data } }
+                : operation,
+            )
+            .concat(sourceUpdate && !sourceAlreadyUpdated ? [sourceUpdate] : []),
+          create: plan.changes.create.map((operation) => ({
+            ...operation,
+            node: finalizedWallsById.get(operation.node.id as WallNode['id']) ?? operation.node,
+          })),
+        },
+        { winnerIds: finalizedWalls.map((wall) => wall.id), mintId: () => generateId('wall') },
+      ),
+    )
     sfxEmitter.emit('sfx:structure-build')
 
     const terminalWall = finalizedWalls.at(-1)!