@pascal-app/editor 1.0.6 → 1.1.0

package/src/lib/room-handle-drag.ts

@@ -16,13 +16,20 @@ import {
   type Point,
   planWallDivision,
   resolveMovedWallSupportSlabPatch,
+  roomFloorElevation,
+  roomOwnPlate,
   runAsSingleSceneHistoryStep,
+  SEPARATOR_JOIN_REACH,
+  type SeparatorNode,
+  type SeparatorSpan,
   type StructureNodes,
   type StructurePlan,
+  separatorFloorElevation,
   setRoomFloorConstruction,
   setWallGeometry,
   setZoneEdges,
   setZoneIntent,
+  translateSeparators,
   upperFloorHeightControl,
   useLiveNodeOverrides,
   useScene,
@@ -42,23 +49,37 @@ import { clientToPlan } from './floorplan/plan-coords'
 import { beginGesture } from './gesture-lifecycle'
 import { isHistoryShortcut } from './history'
 import { MEZZANINE_FAILED_MESSAGE, mezzanineConflictMessage } from './mezzanine-messages'
-import { roomOwnPlate } from './room-built-on'
 import {
   mezzanineEdgeDimensions,
   type RoomDimension,
+  sameRoomDimension,
+  separatorEdgeDimensionRooms,
+  type WallDimensionFaces,
+  type WallSelectionDimension,
   wallPushDimensionRooms,
   wallPushDimensions,
+  wallSelectionDimensions,
 } from './room-push-dimensions'
 import { applyRoomPlan } from './room-structure-commands'
+import { levelSeparatorLines, separatorWallLine } from './separator-lines'
 import { sfxEmitter } from './sfx-bus'
 import { type SpatialPointerId, spatialPointerInput } from './spatial-pointer-input'
 import { isTypingTarget } from './typing-target'
+import {
+  nearestWallParallelTarget,
+  publishWallParallelGuide,
+  type WallParallelTarget,
+  wallParallelTargets,
+} from './wall-parallel-snap'
+import { isWallRunFree } from './wall-run-snap'
 
 export const ROOM_ELEVATION_DRAG_LABEL = 'room-elevation'
 /** Scope label of every wall push: a selected wall's side arrow and a room's boundary arrow. */
 export const WALL_PUSH_DRAG_LABEL = 'wall-push'
 /** Scope label of a mezzanine edge push (its plate grows or shrinks). */
 export const MEZZANINE_EDGE_DRAG_LABEL = 'mezzanine-edge'
+/** What a wall push the planner refuses reads. */
+export const PUSH_REFUSED_MESSAGE = "Can't move this wall there"
 
 /** A wall a push would create (a moved span piece, a bridge), drawn as a ghost. */
 export type RoomPushGhost = { start: Point; end: Point; thickness: number; height: number }
@@ -93,6 +114,20 @@ export type RoomHandleDrag =
       dimensions: RoomDimension[]
       message?: string
     }
+  | {
+      /** Several selected walls moved together, each along its own normal. */
+      kind: 'wall-group-push'
+      levelId: string
+      /** Where a refusal reads: over the moved walls' middle, in level plan coordinates. */
+      anchor: Point
+      height: number
+      /** The lowest moved wall's base, where the ghost pieces stand. */
+      base: number
+      ghosts: RoomPushGhost[]
+      /** Every moved wall's live room widths, as its own push shows them. */
+      dimensions: RoomDimension[]
+      message?: string
+    }
   | {
       kind: 'mezzanine-edge'
       zoneId: string
@@ -113,25 +148,19 @@ export const useRoomHandleDrag = create<{ drag: RoomHandleDrag | null }>(() => (
 
 type Nodes = Record<string, AnyNode>
 
-/** The walking surface of a room: its own elevation, else its plate's. */
-export function roomFloorElevation(nodes: Nodes, zoneId: string): number {
-  const zone = nodes[zoneId]
-  if (zone?.type !== 'zone') return 0
-  const own = roomOwnPlate(nodes, zoneId)
-  if (own) return own.elevation
-  if (typeof zone.floor?.elevation === 'number') return zone.floor.elevation
-  const plate = Object.values(nodes).find(
-    (node) => node.type === 'slab' && node.zoneIds?.includes(zoneId),
-  )
-  return plate?.type === 'slab' ? (plate.elevation ?? 0.05) : 0.05
-}
-
 /**
  * The stretch of a wall a push moves: `[0, 1]` is the whole wall (its
  * neighbours follow through the junction planner), anything shorter is split
- * off first and only that piece moves.
+ * off first and only that piece moves. An edge of invisible walls carries its
+ * stretches in `separators` (`wallId` is the first one's): they move as one
+ * line, the invisible walls joined to them following (`translateSeparators`).
  */
-export type WallPushSpan = { wallId: string; t0: number; t1: number }
+export type WallPushSpan = {
+  wallId: string
+  t0: number
+  t1: number
+  separators?: readonly SeparatorSpan[]
+}
 
 /** One push/pull arrow: a selected wall's side arrow or a room's boundary arrow. */
 export type WallPushHandle = WallPushSpan & {
@@ -166,7 +195,7 @@ function wallPushHandle(
   const offsets = getWallFaceOffsets(wall)
   const face = side === 'a' ? offsets.a : -offsets.b
   const offset = Math.max(face + HANDLE_OFFSET, HANDLE_MIN_OFFSET)
-  const wallHeight = getWallEffectiveHeightForNodes(wall, nodes)
+  const wallHeight = getWallEffectiveHeightForNodes(wall, nodes, 0.5)
   return {
     key,
     wallId: wall.id,
@@ -191,22 +220,27 @@ export function wallPushHandles(wall: WallNode, nodes: Nodes): WallPushHandle[]
   })
 }
 
+type BoundarySpanRef = {
+  boundaryId: string
+  kind: string
+  face: 'a' | 'b'
+  t0: number
+  t1: number
+}
+
 /**
  * One push/pull arrow per boundary wall span of the room, outside the wall's
  * far face, pointing away from the room — where the wall's own side arrow for
- * that face sits. `face` is the wall face the room lies on (`a` = front).
+ * that face sits. `face` is the wall face the room lies on (`a` = front). Its
+ * invisible walls get one arrow per straight edge (`separatorEdges`), lying
+ * at `floor` (the room's floor height), where their dashed line is drawn.
  */
 export function roomPushHandles(
   nodes: Nodes,
-  spans: ReadonlyArray<{
-    boundaryId: string
-    kind: string
-    face: 'a' | 'b'
-    t0: number
-    t1: number
-  }>,
+  spans: ReadonlyArray<BoundarySpanRef>,
+  floor = 0,
 ): WallPushHandle[] {
-  return spans.flatMap((span) => {
+  const walls = spans.flatMap((span) => {
     const wall = nodes[span.boundaryId]
     if (span.kind !== 'wall' || wall?.type !== 'wall') return []
     const handle = wallPushHandle(
@@ -218,6 +252,137 @@ export function roomPushHandles(
     )
     return handle ? [handle] : []
   })
+  const edges = separatorEdges(nodes, spans).map((edge) => {
+    const first = edge.members[0]!
+    return separatorPushHandle(
+      edge,
+      edge.outward,
+      floor,
+      `${first.separatorId}:${edge.face}:${first.t0.toFixed(4)}`,
+    )
+  })
+  return [...walls, ...edges]
+}
+
+/** How far outside an invisible wall (m) its push arrow sits, as a mezzanine edge's does. */
+const SEPARATOR_ARROW_OFFSET = 0.3
+/** Its 3D arrow's lift over the floor: where the invisible wall's dashed line is drawn. */
+const SEPARATOR_ARROW_LIFT = 0.02
+/** An invisible-wall edge shorter than this (m) gets no arrow, as a mezzanine edge. */
+const SEPARATOR_EDGE_MIN_LENGTH = 0.2
+/** Stretches this far off each other's line (m) still run along one edge. */
+const EDGE_IN_LINE = 0.01
+
+type SeparatorEdge = {
+  /** The stretches along the edge, in order. */
+  members: SeparatorSpan[]
+  start: Point
+  end: Point
+  /** Away from the room. */
+  outward: Point
+  face: 'a' | 'b'
+}
+
+/**
+ * A room's invisible-wall stretches gathered into its straight edges: stretches
+ * end to end on one line, the room on the same side, are one edge and push as
+ * one (an edge drawn in two pieces, or broken where another one meets it). Ends
+ * meet as far as the room graph joins them (`SEPARATOR_JOIN_REACH`).
+ */
+function separatorEdges(nodes: Nodes, spans: ReadonlyArray<BoundarySpanRef>): SeparatorEdge[] {
+  const pieces = spans.flatMap((span): SeparatorEdge[] => {
+    const separator = nodes[span.boundaryId]
+    if (span.kind !== 'separator' || separator?.type !== 'separator') return []
+    const dx = separator.end[0] - separator.start[0]
+    const dz = separator.end[1] - separator.start[1]
+    const length = Math.hypot(dx, dz)
+    if (length < 1e-6 || span.t1 - span.t0 < WHOLE) return []
+    // Face `a` is the +normal side: the arrow points the other way, off the room.
+    const sign = span.face === 'a' ? -1 : 1
+    const at = (t: number): Point => [separator.start[0] + dx * t, separator.start[1] + dz * t]
+    return [
+      {
+        members: [{ separatorId: separator.id, t0: span.t0, t1: span.t1 }],
+        start: at(span.t0),
+        end: at(span.t1),
+        outward: [(-dz / length) * sign, (dx / length) * sign],
+        face: span.face,
+      },
+    ]
+  })
+  const across = (edge: SeparatorEdge, [x, z]: Point) =>
+    Math.abs((x - edge.start[0]) * edge.outward[0] + (z - edge.start[1]) * edge.outward[1])
+  const joins = (a: SeparatorEdge, b: SeparatorEdge) =>
+    a.outward[0] * b.outward[0] + a.outward[1] * b.outward[1] > 1 - 1e-4 &&
+    across(a, b.start) < EDGE_IN_LINE &&
+    across(a, b.end) < EDGE_IN_LINE &&
+    [a.start, a.end].some((p) =>
+      [b.start, b.end].some((q) => Math.hypot(p[0] - q[0], p[1] - q[1]) <= SEPARATOR_JOIN_REACH),
+    )
+  let groups: SeparatorEdge[][] = []
+  for (const piece of pieces) {
+    const touching = groups.filter((group) => group.some((other) => joins(piece, other)))
+    groups = [...groups.filter((group) => !touching.includes(group)), [piece, ...touching.flat()]]
+  }
+  return groups.flatMap((group): SeparatorEdge[] => {
+    const { outward, face } = group[0]!
+    const dir: Point = [outward[1], -outward[0]]
+    const along = ([x, z]: Point) => x * dir[0] + z * dir[1]
+    const ends = group
+      .flatMap((piece) => [piece.start, piece.end])
+      .sort((p, q) => along(p) - along(q))
+    const start = ends[0]!
+    const end = ends.at(-1)!
+    if (Math.hypot(end[0] - start[0], end[1] - start[1]) < SEPARATOR_EDGE_MIN_LENGTH) return []
+    const middle = (piece: SeparatorEdge) => along(piece.start) + along(piece.end)
+    const members = [...group].sort((p, q) => middle(p) - middle(q)).flatMap((p) => p.members)
+    return [{ members, start, end, outward, face }]
+  })
+}
+
+function separatorPushHandle(
+  edge: Pick<SeparatorEdge, 'members' | 'start' | 'end'>,
+  outward: Point,
+  floor: number,
+  key: string,
+): WallPushHandle {
+  const first = edge.members[0]!
+  const middle: Point = [(edge.start[0] + edge.end[0]) / 2, (edge.start[1] + edge.end[1]) / 2]
+  return {
+    key,
+    wallId: first.separatorId,
+    t0: first.t0,
+    t1: first.t1,
+    separators: edge.members,
+    position: [
+      middle[0] + outward[0] * SEPARATOR_ARROW_OFFSET,
+      middle[1] + outward[1] * SEPARATOR_ARROW_OFFSET,
+    ],
+    height: floor + SEPARATOR_ARROW_LIFT,
+    outward,
+    line: middle[0] * outward[0] + middle[1] * outward[1],
+  }
+}
+
+/**
+ * A selected invisible wall's two side arrows, one off each side, at `floor`:
+ * each pushes the whole separator, the ones joined to it following.
+ */
+export function separatorPushHandles(separator: SeparatorNode, floor = 0): WallPushHandle[] {
+  const dx = separator.end[0] - separator.start[0]
+  const dz = separator.end[1] - separator.start[1]
+  const length = Math.hypot(dx, dz)
+  if (length < 1e-6) return []
+  const edge = {
+    members: [{ separatorId: separator.id, t0: 0, t1: 1 }],
+    start: separator.start,
+    end: separator.end,
+  }
+  return (['a', 'b'] as const).map((side) => {
+    const sign = side === 'a' ? 1 : -1
+    const outward: Point = [(-dz / length) * sign, (dx / length) * sign]
+    return separatorPushHandle(edge, outward, floor, `${separator.id}:${side}`)
+  })
 }
 
 /**
@@ -294,7 +459,8 @@ function diffNodes(before: Scratch, after: Scratch): NodeChange[] {
  * Pushes the room's stretch of a wall `distance` along `outward`. A span that
  * covers the whole wall moves the wall; a partial span is split off at its
  * ends first (hosted openings stay on their pieces) and only that piece moves,
- * bridged back to the rest by the junction planner. One plan, one undo step.
+ * bridged back to the rest by the junction planner. An edge of invisible walls
+ * moves as one line (`translateSeparators`). One plan, one undo step.
  */
 export function planRoomPush(
   nodes: StructureNodes,
@@ -303,6 +469,12 @@ export function planRoomPush(
   distance: number,
   mintId: (kind: 'zone' | 'wall' | 'separator') => string = generateId,
 ): StructurePlan {
+  if (span.separators?.length)
+    return translateSeparators(nodes, {
+      spans: span.separators,
+      offset: [outward[0] * distance, outward[1] * distance],
+      mintId,
+    })
   const wall = nodes[span.wallId]
   if (wall?.type !== 'wall') throw Error('Select a wall.')
   const shift = ([x, z]: Point): Point => [x + outward[0] * distance, z + outward[1] * distance]
@@ -388,14 +560,18 @@ function clearPushPreview() {
 function previewSurfaces(nodes: Nodes, levelId: string, after: Scratch) {
   if (surfacePreview?.levelId !== levelId || surfacePreview.nodes !== nodes)
     surfacePreview = { levelId, nodes, run: createLevelStructurePreview(levelId, nodes) }
-  const walls = Object.values(after).filter(
-    (node): node is WallNode => node.type === 'wall' && node.parentId === levelId,
-  )
+  const level = Object.values(after).filter((node) => node.parentId === levelId)
   return surfacePreview
-    .run(walls)
+    .run(
+      level.filter((node): node is WallNode => node.type === 'wall'),
+      level.filter((node): node is SeparatorNode => node.type === 'separator'),
+    )
     .map((patch) => [patch.id as AnyNodeId, patch.data as Partial<AnyNode>] as const)
 }
 
+/** The ghost of an invisible wall a push would create (a jog): a thin strip on the floor. */
+const SEPARATOR_GHOST = { thickness: 0.03, height: 0.04 }
+
 /**
  * Shows the push live: the plan's updates to existing walls — and the room
  * surfaces reshaped around them — ride `useLiveNodeOverrides` (renderers merge
@@ -410,9 +586,20 @@ export function previewRoomPush(
   clearPushPreview()
   if (Math.abs(distance) < 1e-6) return { ghosts: [] }
   const nodes = useScene.getState().nodes
+  return previewPushPlan(nodes, nodes[span.wallId as AnyNodeId]?.parentId, () =>
+    planRoomPush(nodes, span, outward, distance, previewMint()),
+  )
+}
+
+/** Shows a push plan live (`previewRoomPush`); the caller has cleared the last one. */
+function previewPushPlan(
+  nodes: Nodes,
+  levelId: string | null | undefined,
+  planPush: () => StructurePlan,
+): { code?: string; ghosts: RoomPushGhost[] } {
   let plan: StructurePlan
   try {
-    plan = planRoomPush(nodes, span, outward, distance, previewMint())
+    plan = planPush()
   } catch {
     return { code: 'invalid-geometry', ghosts: [] }
   }
@@ -420,25 +607,27 @@ export function previewRoomPush(
   const updates: Array<readonly [AnyNodeId, Partial<AnyNode>]> = plan.changes.flatMap((change) =>
     change.op === 'update' ? [[change.id as AnyNodeId, change.data] as const] : [],
   )
-  const levelId = nodes[span.wallId as AnyNodeId]?.parentId
   if (levelId) updates.push(...previewSurfaces(nodes, levelId, applyChanges(nodes, plan.changes)))
   useLiveNodeOverrides
     .getState()
     .setMany(updates.map(([id, data]) => [id, data] as [AnyNodeId, Partial<AnyNode>]))
   previewIds = updates.map(([id]) => id)
   for (const id of previewIds) useScene.getState().markDirty(id as AnyNodeId)
-  const ghosts = plan.changes.flatMap((change): RoomPushGhost[] =>
-    change.op === 'create' && change.node.type === 'wall'
+  const ghosts = plan.changes.flatMap((change): RoomPushGhost[] => {
+    if (change.op !== 'create') return []
+    if (change.node.type === 'separator')
+      return [{ start: change.node.start, end: change.node.end, ...SEPARATOR_GHOST }]
+    return change.node.type === 'wall'
       ? [
           {
             start: change.node.start,
             end: change.node.end,
             thickness: change.node.thickness ?? 0.1,
-            height: getWallEffectiveHeightForNodes(change.node, nodes),
+            height: getWallEffectiveHeightForNodes(change.node, nodes, 0),
           },
         ]
-      : [],
-  )
+      : []
+  })
   // The floor plan draws the same pieces through its bridge-ghost layer.
   if (ghosts.length) {
     useWallMoveGhosts.getState().setBridges(
@@ -468,9 +657,13 @@ export function endRoomPushPreview() {
 export function commitRoomPush(span: WallPushSpan, outward: Point, distance: number) {
   endRoomPushPreview()
   if (Math.abs(distance) < 1e-6) return true
+  return commitPushPlan((nodes) => planRoomPush(nodes, span, outward, distance))
+}
+
+function commitPushPlan(planPush: (nodes: StructureNodes) => StructurePlan) {
   try {
     return runAsSingleSceneHistoryStep(useScene, () => {
-      const plan = planRoomPush(useScene.getState().nodes, span, outward, distance)
+      const plan = planPush(useScene.getState().nodes)
       if (!applyRoomPlan(plan)) return false
       const nodes = useScene.getState().nodes
       const patches = plan.changes.flatMap((change) => {
@@ -716,12 +909,13 @@ export function cancelRoomHandleDrag() {
 /**
  * Runs one handle drag on window listeners, independent of the handle's own
  * mount (handles hide while any scope is active). `sample` maps a pointer to
- * the drag's value (`spatial.sample` a controller ray, for a spatial pointer);
- * release commits, Escape / ⌘Z / the gesture owner cancel. Cleanup runs
+ * the drag's value (`spatial.sample` a controller ray, for a spatial pointer):
+ * a distance or a height, or a plan point for an end dragged across the floor.
+ * Release commits, Escape / ⌘Z / the gesture owner cancel. Cleanup runs
  * exactly once whatever happens, and releases only this drag's own scope;
  * nothing republishes a preview after it.
  */
-export function runRoomHandleDrag({
+export function runRoomHandleDrag<T = number>({
   label,
   nodeId,
   zoneId,
@@ -738,9 +932,9 @@ export function runRoomHandleDrag({
   zoneId?: string
   levelId: string
   requires: string[]
-  sample: (clientX: number, clientY: number) => number | null
-  spatial?: { pointerId: SpatialPointerId; sample: (ray: Ray) => number | null }
-  onValue: (value: number) => void
+  sample: (clientX: number, clientY: number) => T | null
+  spatial?: { pointerId: SpatialPointerId; sample: (ray: Ray) => T | null }
+  onValue: (value: T) => void
   onCommit: () => void
   onCancel: () => void
 }) {
@@ -891,10 +1085,20 @@ export function runWallPushDrag({
   spatial?: { pointerId: SpatialPointerId; along: (ray: Ray) => number | null }
 }) {
   const nodes = useScene.getState().nodes
-  const wall = nodes[handle.wallId as AnyNodeId]
-  if (wall?.type !== 'wall') return null
-  const base = getWallBaseElevationForNodes(wall, nodes)
+  const boundary = nodes[handle.wallId as AnyNodeId]
+  // An edge of invisible walls is measured, and lines up, as the one line it moves as.
+  const edge = handle.separators?.length ? separatorEdgeLine(nodes, handle.separators) : null
+  const wall = edge ?? (boundary?.type === 'wall' ? boundary : null)
+  if (!wall) return null
+  const base =
+    wall.type === 'wall'
+      ? getWallBaseElevationForNodes(wall, nodes)
+      : handle.height - SEPARATOR_ARROW_LIFT
   const rooms = pushDimensionRooms(nodes, levelId, handle, base)
+  const levelWalls = Object.values(nodes).filter(
+    (node): node is WallNode => node.type === 'wall' && node.parentId === levelId,
+  )
+  const moving = new Set([handle.wallId, ...(handle.separators ?? []).map((s) => s.separatorId)])
   let distance = 0
   let blocked = false
   let ghosts: RoomPushGhost[] = []
@@ -921,15 +1125,49 @@ export function runWallPushDrag({
         message,
       },
     })
-  const toDistance = (at: number | null) =>
-    at === null ? null : snapPushDistance(handle.line, at - from)
+  // The pushed wall lines up with the parallel walls on its level
+  // (`wall-parallel-snap`) before the grid; Alt pushes it free. Invisible walls
+  // line up with the walls and with the level's other invisible walls.
+  const lineUpTargets =
+    wall.type === 'wall'
+      ? wallParallelTargets(wall, handle.outward, levelWalls)
+      : wallParallelTargets(separatorWallLine(wall), handle.outward, [
+          ...levelWalls,
+          ...levelSeparatorLines(nodes, levelId, moving),
+        ])
+  let lineUp: WallParallelTarget | null = null
+  let altHeld = false
+  const trackAlt = (event: KeyboardEvent | PointerEvent) => {
+    altHeld = event.altKey
+  }
+  window.addEventListener('pointermove', trackAlt, true)
+  window.addEventListener('keydown', trackAlt, true)
+  window.addEventListener('keyup', trackAlt, true)
+  const stopLineUp = () => {
+    window.removeEventListener('pointermove', trackAlt, true)
+    window.removeEventListener('keydown', trackAlt, true)
+    window.removeEventListener('keyup', trackAlt, true)
+    if (lineUp) publishWallParallelGuide(null)
+    lineUp = null
+  }
+  const toDistance = (at: number | null) => {
+    if (at === null) return null
+    const raw = at - from
+    const next = isWallRunFree({ altKey: altHeld })
+      ? null
+      : nearestWallParallelTarget(lineUpTargets, handle.line + raw)
+    if (next !== lineUp) publishWallParallelGuide(next)
+    lineUp = next
+    if (next) return next.position - handle.line
+    return isWallRunFree({ altKey: altHeld }) ? raw : snapPushDistance(handle.line, raw)
+  }
   publish()
   return runRoomHandleDrag({
     label: WALL_PUSH_DRAG_LABEL,
     nodeId: handle.wallId,
     zoneId,
     levelId,
-    requires: zoneId ? [zoneId, handle.wallId] : [handle.wallId],
+    requires: zoneId ? [zoneId, ...moving] : [...moving],
     sample: (x, y) => toDistance(along(x, y)),
     spatial: spatial && {
       pointerId: spatial.pointerId,
@@ -942,13 +1180,17 @@ export function runWallPushDrag({
       const preview = previewRoomPush(handle, handle.outward, distance)
       ghosts = preview.ghosts
       blocked = !!preview.code
-      publish(preview.code ? "Can't move this wall there" : undefined)
+      publish(preview.code ? PUSH_REFUSED_MESSAGE : undefined)
     },
     onCommit: () => {
+      stopLineUp()
       if (blocked) endRoomPushPreview()
       else commitRoomPush(handle, handle.outward, distance)
     },
-    onCancel: () => endRoomPushPreview(),
+    onCancel: () => {
+      stopLineUp()
+      endRoomPushPreview()
+    },
   })
 }
 
@@ -960,10 +1202,258 @@ function pushDimensionRooms(nodes: Nodes, levelId: string, span: WallPushSpan, b
   const index = getRoomSelectionIndex(levelId)
   const records = index.update(nodes)
   const topology = index.topology.getLevelTopology(levelId)
-  return wallPushDimensionRooms(topology?.rooms ?? [], span, (roomId) => {
+  const elevationOf = (roomId: string) => {
     const zoneId = records.find((record) => record.id === roomId)?.zoneId
     return zoneId ? roomFloorElevation(nodes, zoneId) : base
+  }
+  const edge = span.separators?.length ? separatorEdgeLine(nodes, span.separators) : null
+  return edge && span.separators
+    ? separatorEdgeDimensionRooms(
+        topology?.rooms ?? [],
+        { line: edge, separators: span.separators },
+        (id) => nodes[id],
+        elevationOf,
+      )
+    : wallPushDimensionRooms(topology?.rooms ?? [], span, elevationOf)
+}
+
+/**
+ * The one line an edge of invisible walls pushes as: its first separator,
+ * running from the edge's first end to its last.
+ */
+function separatorEdgeLine(nodes: Nodes, spans: readonly SeparatorSpan[]): SeparatorNode | null {
+  const first = nodes[spans[0]?.separatorId as AnyNodeId]
+  if (first?.type !== 'separator') return null
+  const dx = first.end[0] - first.start[0]
+  const dz = first.end[1] - first.start[1]
+  const length = Math.hypot(dx, dz)
+  if (length < 1e-6) return null
+  const along = ([x, z]: Point) =>
+    ((x - first.start[0]) * dx + (z - first.start[1]) * dz) / (length * length)
+  let lo = Number.POSITIVE_INFINITY
+  let hi = Number.NEGATIVE_INFINITY
+  for (const span of spans) {
+    const separator = nodes[span.separatorId as AnyNodeId]
+    if (separator?.type !== 'separator') return null
+    for (const t of [span.t0, span.t1]) {
+      const u = along([
+        separator.start[0] + (separator.end[0] - separator.start[0]) * t,
+        separator.start[1] + (separator.end[1] - separator.start[1]) * t,
+      ])
+      lo = Math.min(lo, u)
+      hi = Math.max(hi, u)
+    }
+  }
+  const at = (u: number): Point => [first.start[0] + dx * u, first.start[1] + dz * u]
+  return { ...first, start: at(lo), end: at(hi) }
+}
+
+/**
+ * A selected wall's temporary dimensions as the scene stands: the room widths
+ * its push shows, before any push, plus the outside size for an exterior wall.
+ */
+export function selectedWallDimensions(
+  nodes: Nodes,
+  wall: WallNode,
+  faces: WallDimensionFaces,
+): WallSelectionDimension[] {
+  const levelId = wall.parentId
+  if (!levelId) return []
+  const base = getWallBaseElevationForNodes(wall, nodes)
+  const walls = Object.values(nodes).filter(
+    (node): node is WallNode => node.type === 'wall' && node.parentId === levelId,
+  )
+  return wallSelectionDimensions({
+    rooms: pushDimensionRooms(nodes, levelId, { wallId: wall.id, t0: 0, t1: 1 }, base),
+    wall,
+    walls,
+    faces,
+    resolve: (id) => nodes[id],
+    baseElevation: base,
+  })
+}
+
+/** An end this close to another moved wall is joined to it. */
+const GROUP_JOIN_REACH = 1e-3
+/** Walls whose directions cross by less than this (sine) run in line, never meet at a corner. */
+const GROUP_PARALLEL_SIN = 1e-4
+
+/** The way a wall's push arrows point: its `a`-side normal at its middle. */
+function wallPushNormal(wall: WallNode): Point {
+  const frame = getWallCurveFrameAt(wall, 0.5)
+  return [frame.normal.x, frame.normal.y]
+}
+
+function wallDirection(wall: WallNode): Point {
+  const dx = wall.end[0] - wall.start[0]
+  const dz = wall.end[1] - wall.start[1]
+  const length = Math.hypot(dx, dz) || 1
+  return [dx / length, dz / length]
+}
+
+/** Whether `point` is on `wall`: one of its ends, or along a straight one. */
+function wallHoldsPoint(wall: WallNode, [x, z]: Point): boolean {
+  const near = ([px, pz]: Point) => Math.hypot(px - x, pz - z) <= GROUP_JOIN_REACH
+  if (near(wall.start) || near(wall.end)) return true
+  if ((wall.curveOffset ?? 0) !== 0) return false
+  const [ux, uz] = wallDirection(wall)
+  const along = (x - wall.start[0]) * ux + (z - wall.start[1]) * uz
+  const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1])
+  return (
+    along > 0 &&
+    along < length &&
+    Math.abs((z - wall.start[1]) * ux - (x - wall.start[0]) * uz) <= GROUP_JOIN_REACH
+  )
+}
+
+/**
+ * Moves several walls at once, each as its own push arrow would: along its
+ * normal by `drag` projected on it, so it stays parallel to where it was, the
+ * walls joined to it following through the junction planner. An end on
+ * another moved wall that is not in line with it (a corner or a T between
+ * them) sits on both moved lines, which is where it lands moved by the whole
+ * drag, so they stay joined. Each wall is planned in turn while the others
+ * already stand at their targets, so no moved wall is pulled along as
+ * another's neighbour. One plan, one undo step.
+ */
+export function planWallGroupPush(
+  nodes: StructureNodes,
+  wallIds: readonly string[],
+  drag: Point,
+  mintId: (kind: 'zone' | 'wall' | 'separator') => string = generateId,
+): StructurePlan {
+  const walls = wallIds.flatMap((id) => {
+    const node = nodes[id]
+    return node?.type === 'wall' ? [node] : []
+  })
+  const crosses = (a: WallNode, b: WallNode) => {
+    const [ux, uz] = wallDirection(a)
+    const [vx, vz] = wallDirection(b)
+    return Math.abs(ux * vz - uz * vx) > GROUP_PARALLEL_SIN
+  }
+  let scratch: Scratch = { ...nodes }
+  for (const wall of walls) {
+    const [nx, nz] = wallPushNormal(wall)
+    const distance = drag[0] * nx + drag[1] * nz
+    const move = (point: Point): Point =>
+      walls.some((other) => other !== wall && crosses(wall, other) && wallHoldsPoint(other, point))
+        ? [point[0] + drag[0], point[1] + drag[1]]
+        : [point[0] + nx * distance, point[1] + nz * distance]
+    scratch[wall.id] = { ...wall, start: move(wall.start), end: move(wall.end) }
+  }
+  for (const wall of walls) {
+    const target = scratch[wall.id]
+    if (target?.type !== 'wall') continue
+    scratch[wall.id] = { ...target, start: wall.start, end: wall.end }
+    const moved = setWallGeometry(scratch, {
+      wallId: wall.id,
+      start: target.start,
+      end: target.end,
+      mintId,
+    })
+    if (moved.conflicts?.length) return moved
+    scratch = applyChanges(scratch, moved.changes)
+  }
+  return { changes: diffNodes(nodes, scratch) }
+}
+
+/** A multi-wall push in flight (`beginWallGroupPush`). */
+export type WallGroupPush = {
+  /** Previews the walls moved by the level-plan drag. */
+  preview: (drag: Point) => void
+  /** Writes the last preview as one undo step; false when nothing was written. */
+  commit: () => boolean
+  /** Drops the preview; the scene is untouched. */
+  cancel: () => void
+}
+
+/**
+ * The live side of `planWallGroupPush`, for a group move whose selection is
+ * walls only: the walls, their neighbours and the room surfaces preview
+ * through overrides, created pieces as ghosts, and each wall's room widths
+ * show as its own push shows them (`useRoomHandleDrag`, kind
+ * `wall-group-push`). The caller owns the gesture: its pointer, keys and scope.
+ */
+export function beginWallGroupPush(wallIds: readonly string[], levelId: string): WallGroupPush {
+  const nodes = useScene.getState().nodes
+  const measured = wallIds.flatMap((id) => {
+    const wall = nodes[id as AnyNodeId]
+    if (wall?.type !== 'wall') return []
+    const base = getWallBaseElevationForNodes(wall, nodes)
+    return [
+      {
+        wall,
+        base,
+        top: base + getWallEffectiveHeightForNodes(wall, nodes, 0),
+        normal: wallPushNormal(wall),
+        rooms: pushDimensionRooms(nodes, levelId, { wallId: wall.id, t0: 0, t1: 1 }, base),
+      },
+    ]
   })
+  const middle: Point = [0, 0]
+  for (const { wall } of measured) {
+    middle[0] += (wall.start[0] + wall.end[0]) / 2 / measured.length
+    middle[1] += (wall.start[1] + wall.end[1]) / 2 / measured.length
+  }
+  let drag: Point = [0, 0]
+  let blocked = false
+  let shown = false
+  const dimensions = () => {
+    const kept: RoomDimension[] = []
+    for (const { wall, normal, rooms } of measured) {
+      const distance = drag[0] * normal[0] + drag[1] * normal[1]
+      // Two moved walls across one room both measure it: the width shows once.
+      for (const dimension of wallPushDimensions({
+        rooms,
+        wall,
+        outward: normal,
+        distance,
+        resolve: livePreviewNode,
+      }))
+        if (!kept.some((other) => sameRoomDimension(other, dimension)))
+          kept.push({ ...dimension, key: `${wall.id}:${dimension.key}` })
+    }
+    return kept
+  }
+  const publish = (ghosts: RoomPushGhost[], message?: string) =>
+    useRoomHandleDrag.setState({
+      drag: {
+        kind: 'wall-group-push',
+        levelId,
+        anchor: [middle[0] + drag[0], middle[1] + drag[1]],
+        height: Math.max(...measured.map(({ top }) => top)),
+        base: Math.min(...measured.map(({ base }) => base)),
+        ghosts,
+        dimensions: dimensions(),
+        message,
+      },
+    })
+  const end = () => {
+    endRoomPushPreview()
+    useRoomHandleDrag.setState({ drag: null })
+  }
+  return {
+    preview: (next) => {
+      if (shown && next[0] === drag[0] && next[1] === drag[1]) return
+      shown = true
+      drag = [next[0], next[1]]
+      clearPushPreview()
+      const preview =
+        Math.hypot(drag[0], drag[1]) < 1e-6
+          ? { ghosts: [] }
+          : previewPushPlan(useScene.getState().nodes, levelId, () =>
+              planWallGroupPush(useScene.getState().nodes, wallIds, drag, previewMint()),
+            )
+      blocked = !!preview.code
+      publish(preview.ghosts, preview.code ? PUSH_REFUSED_MESSAGE : undefined)
+    },
+    commit: () => {
+      end()
+      if (blocked || Math.hypot(drag[0], drag[1]) < 1e-6) return false
+      return commitPushPlan((current) => planWallGroupPush(current, wallIds, drag))
+    },
+    cancel: end,
+  }
 }
 
 /** A node as the push preview draws it: the scene's, with its live override merged. */
@@ -986,6 +1476,7 @@ export function wallPointAt(wall: WallNode, t: number): Point {
  */
 export const WALL_PUSH_AFFORDANCE = 'wall-push'
 
+/** A wall's or an invisible wall's side arrow: `wallId` is either. */
 export type WallPushArrowPayload = { wallId: string; side: 'a' | 'b' }
 
 type PlanPointer = (clientX: number, clientY: number) => readonly [number, number] | null
@@ -1001,8 +1492,9 @@ function planAlong(position: Point, outward: Point, toPlan: PlanPointer) {
 }
 
 /**
- * A floor-plan wall arrow: the 3D arrow's handle (`wallPushHandles`), drag
- * (`runWallPushDrag`) and commit, with the pointer read in plan coordinates.
+ * A floor-plan wall arrow: the 3D arrow's handle (`wallPushHandles`, or a
+ * selected invisible wall's `separatorPushHandles`), drag (`runWallPushDrag`)
+ * and commit, with the pointer read in plan coordinates.
  */
 export function runFloorplanWallPush(
   payload: unknown,
@@ -1013,8 +1505,12 @@ export function runFloorplanWallPush(
   const { wallId, side } = (payload ?? {}) as Partial<WallPushArrowPayload>
   const nodes = useScene.getState().nodes
   const wall = wallId ? nodes[wallId as AnyNodeId] : undefined
-  if (wall?.type !== 'wall' || !wall.parentId) return null
-  const handle = wallPushHandles(wall, nodes).find((h) => h.key === `${wall.id}:${side}`)
+  if ((wall?.type !== 'wall' && wall?.type !== 'separator') || !wall.parentId) return null
+  const handles =
+    wall.type === 'wall'
+      ? wallPushHandles(wall, nodes)
+      : separatorPushHandles(wall, separatorFloorElevation(nodes, wall.id))
+  const handle = handles.find((h) => h.key === `${wall.id}:${side}`)
   if (!handle) return null
   return runFloorplanRoomPush({ handle, levelId: wall.parentId, clientX, clientY, toPlan })
 }