@pascal-app/editor 1.0.6 → 1.1.0

package/src/lib/contextual-help.ts

@@ -1,12 +1,14 @@
+import type { MessageDescriptor } from '@pascal-app/core'
+
 export type ContextualShortcutHint = {
   // A combo of keys pressed together (rendered joined by "+"). An entry may
   // itself be an array of alternatives (rendered joined by "/"), e.g.
   // [['Cmd/Ctrl', 'Shift'], 'Left click'] → "⌘ / ⇧ + click".
   keys: Array<string | string[]>
-  label: string
+  label: MessageDescriptor | string
   // Optional secondary line under the label for a terser qualifier
   // (e.g. "disable 15° snap"). The HUD wraps both lines rather than truncating.
-  subtitle?: string
+  subtitle?: MessageDescriptor | string
   active?: boolean
 }
 
@@ -29,11 +31,25 @@ export const RESIZE_HANDLE_DRAG_LABEL = 'resize-handle'
 export const GROUP_MOVE_DRAG_LABEL = 'group-move-handle'
 export const GROUP_ROTATE_DRAG_LABEL = 'group-rotate-handle'
 
+// `activeHandleDrag.label`s for the MEP handles, in 3D and on the plan: one
+// point of a run, where Alt detaches the joint, and a fitting, a run or one
+// run segment slid along an axis. Their snap context is the kind's own.
+export const PATH_POINT_DRAG_LABEL = 'path-point'
+export const AXIS_MOVE_DRAG_LABEL = 'axis-move'
+
 export function resolveRotateHandleHelpHints(altPressed: boolean): ContextualShortcutHint[] {
   return [
     {
       keys: [ALT_KEY],
-      label: altPressed ? 'Rotating freely (no angle step)' : 'Hold to rotate freely',
+      label: altPressed
+        ? /* i18n */ {
+            id: 'editor.lib.contextualHelp.rotatingFreely',
+            message: 'Rotating freely (no angle step)',
+          }
+        : /* i18n */ {
+            id: 'editor.lib.contextualHelp.holdToRotateFreely',
+            message: 'Hold to rotate freely',
+          },
       active: altPressed,
     },
   ]
@@ -77,7 +93,10 @@ export function resolveSelectModeHelpHints({
 
     hints.push({
       keys: [[COMMAND_KEY, SHIFT_KEY], LEFT_CLICK],
-      label: 'Add or remove objects from the selection',
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.addOrRemoveObjectsFromThe',
+        message: 'Add or remove objects from the selection',
+      },
       active: true,
     })
     return hints
@@ -89,23 +108,47 @@ export function resolveSelectModeHelpHints({
   if (selectedCount > 1) {
     hints.push({
       keys: [LEFT_CLICK],
-      label: 'Click or drag the selection to move it as one',
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.clickOrDragTheSelectionTo',
+        message: 'Click or drag the selection to move it as one',
+      },
+    })
+    hints.push({
+      keys: [ROTATE_KEYS],
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.rotateTheSelection45',
+        message: 'Rotate the selection ±45°',
+      },
     })
-    hints.push({ keys: [ROTATE_KEYS], label: 'Rotate the selection ±45°' })
     hints.push({
       keys: [COMMAND_KEY, 'G'],
-      label: 'Group selection (session only)',
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.groupSelectionSessionOnly',
+        message: 'Group selection (session only)',
+      },
     })
     hints.push({
       keys: [COMMAND_KEY, SHIFT_KEY, 'G'],
-      label: 'Ungroup session selection',
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.ungroupSessionSelection',
+        message: 'Ungroup session selection',
+      },
     })
     hints.push({
       keys: [[COMMAND_KEY, SHIFT_KEY], LEFT_CLICK],
-      label: 'Add or remove objects from the selection',
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.addOrRemoveObjectsFromThe',
+        message: 'Add or remove objects from the selection',
+      },
       active: commandPressed || shiftPressed,
     })
-    hints.push({ keys: [ESC_KEY], label: 'Clear the selection (or click outside)' })
+    hints.push({
+      keys: [ESC_KEY],
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.clearTheSelectionOrClickOutside',
+        message: 'Clear the selection (or click outside)',
+      },
+    })
     return hints
   }
 
@@ -115,12 +158,39 @@ export function resolveSelectModeHelpHints({
   // detaches the joint mid-drag; a fitting's cluster adds rotate arcs, with
   // R / T (and Alt to switch axis) for keyboard rotation.
   if (mepSelection === 'run') {
-    hints.push({ keys: [CLICK], label: 'Click a handle dot to show move arrows' })
-    hints.push({ keys: [ALT_KEY], label: 'Detach the joint while dragging an arrow' })
+    hints.push({
+      keys: [CLICK],
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.clickAHandleDotToShow',
+        message: 'Click a handle dot to show move arrows',
+      },
+    })
+    hints.push({
+      keys: [ALT_KEY],
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.detachTheJointWhileDraggingAn',
+        message: 'Detach the joint while dragging an arrow',
+      },
+    })
   } else if (mepSelection === 'fitting') {
-    hints.push({ keys: [CLICK], label: 'Click the handle dot to show move + rotate handles' })
-    hints.push({ keys: [ROTATE_KEYS], label: 'Rotate ±45°' })
-    hints.push({ keys: [ALT_KEY], label: 'Switch the rotation axis (Y → X → Z)' })
+    hints.push({
+      keys: [CLICK],
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.clickTheHandleDotToShow',
+        message: 'Click the handle dot to show move + rotate handles',
+      },
+    })
+    hints.push({
+      keys: [ROTATE_KEYS],
+      label: /* i18n */ { id: 'editor.lib.contextualHelp.rotate45', message: 'Rotate ±45°' },
+    })
+    hints.push({
+      keys: [ALT_KEY],
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.switchTheRotationAxisYX',
+        message: 'Switch the rotation axis (Y → X → Z)',
+      },
+    })
   }
 
   // The rows are the same whatever modifier is held — guides/snapping are
@@ -130,28 +200,40 @@ export function resolveSelectModeHelpHints({
   if (hasMovableSelection) {
     hints.push({
       keys: [LEFT_CLICK],
-      label: 'Drag selected movable object',
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.dragSelectedMovableObject',
+        message: 'Drag selected movable object',
+      },
     })
   }
 
   if (hasRotatableSelection) {
     hints.push({
       keys: [COMMAND_KEY, RIGHT_CLICK],
-      label: 'Drag left or right to rotate selected object',
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.dragLeftOrRightToRotate',
+        message: 'Drag left or right to rotate selected object',
+      },
     })
   }
 
   if (hasOpeningRadiusSelection) {
     hints.push({
       keys: [SHIFT_KEY],
-      label: 'Adjust one side’s corner radius',
+      label: /* i18n */ {
+        id: 'editor.lib.contextualHelp.adjustOneSideSCornerRadius',
+        message: 'Adjust one side’s corner radius',
+      },
       active: shiftPressed,
     })
   }
 
   hints.push({
     keys: [[COMMAND_KEY, SHIFT_KEY], LEFT_CLICK],
-    label: 'Add or remove objects from the selection',
+    label: /* i18n */ {
+      id: 'editor.lib.contextualHelp.addOrRemoveObjectsFromThe',
+      message: 'Add or remove objects from the selection',
+    },
     active: commandPressed || shiftPressed,
   })
 

package/src/lib/continuation.ts

@@ -1,3 +1,4 @@
+import type { MessageDescriptor } from '@pascal-app/core'
 export type ContinuationContext = 'wall' | 'fence' | 'point' | 'cabinet' | 'canopy'
 export type ContinuationMode = string
 
@@ -6,7 +7,7 @@ export const CONTINUATION_PROFILES: Record<
   {
     options: ContinuationMode[]
     default: ContinuationMode
-    labels: Record<string, string>
+    labels: Record<string, MessageDescriptor>
     icons: Record<string, string>
     /**
      * Picked once from the Build panel before drawing (`wall-draw-variant.ts`),
@@ -17,11 +18,19 @@ export const CONTINUATION_PROFILES: Record<
 > = {
   // The wall tool's drawing mode: a chain that closes into a room ('room', the
   // Build panel's Polygon), one wall per two clicks ('single', Walls), or a
-  // two-corner box of four walls ('rectangle', Rectangle).
+  // two-corner box of four walls ('rectangle', Rectangle). The last one picked
+  // is what B arms; Rectangle until one is.
   wall: {
     options: ['room', 'single', 'rectangle'],
-    default: 'room',
-    labels: { room: 'Polygon room', single: 'Walls', rectangle: 'Rectangle room' },
+    default: 'rectangle',
+    labels: {
+      room: /* i18n */ { id: 'editor.lib.continuation.polygonRoom', message: 'Polygon room' },
+      single: /* i18n */ { id: 'editor.lib.continuation.walls', message: 'Walls' },
+      rectangle: /* i18n */ {
+        id: 'editor.lib.continuation.rectangleRoom',
+        message: 'Rectangle room',
+      },
+    },
     icons: { room: 'lucide:pentagon', single: 'lucide:minus', rectangle: 'lucide:square' },
     chosenInPanel: true,
   },
@@ -29,10 +38,13 @@ export const CONTINUATION_PROFILES: Record<
     options: ['single', 'continuous', 'curved', 'freehand'],
     default: 'continuous',
     labels: {
-      continuous: 'Continuous',
-      single: 'Single fence',
-      curved: 'Curved fence',
-      freehand: 'Freehand fence',
+      continuous: /* i18n */ { id: 'editor.lib.continuation.continuous', message: 'Continuous' },
+      single: /* i18n */ { id: 'editor.lib.continuation.singleFence', message: 'Single fence' },
+      curved: /* i18n */ { id: 'editor.lib.continuation.curvedFence', message: 'Curved fence' },
+      freehand: /* i18n */ {
+        id: 'editor.lib.continuation.freehandFence',
+        message: 'Freehand fence',
+      },
     },
     icons: {
       continuous: 'lucide:waypoints',
@@ -44,19 +56,34 @@ export const CONTINUATION_PROFILES: Record<
   point: {
     options: ['once', 'repeat'],
     default: 'once',
-    labels: { once: 'Place once', repeat: 'Place multiple' },
+    labels: {
+      once: /* i18n */ { id: 'editor.lib.continuation.placeOnce', message: 'Place once' },
+      repeat: /* i18n */ { id: 'editor.lib.continuation.placeMultiple', message: 'Place multiple' },
+    },
     icons: { once: 'lucide:target', repeat: 'lucide:copy-plus' },
   },
   cabinet: {
     options: ['single', 'continuous'],
     default: 'single',
-    labels: { single: 'Single cabinet', continuous: 'Continuous run' },
+    labels: {
+      single: /* i18n */ { id: 'editor.lib.continuation.singleCabinet', message: 'Single cabinet' },
+      continuous: /* i18n */ {
+        id: 'editor.lib.continuation.continuousRun',
+        message: 'Continuous run',
+      },
+    },
     icons: { single: 'lucide:minus', continuous: 'lucide:waypoints' },
   },
   canopy: {
     options: ['single', 'continuous'],
     default: 'single',
-    labels: { single: 'Single canopy', continuous: 'Continuous canopy' },
+    labels: {
+      single: /* i18n */ { id: 'editor.lib.continuation.singleCanopy', message: 'Single canopy' },
+      continuous: /* i18n */ {
+        id: 'editor.lib.continuation.continuousCanopy',
+        message: 'Continuous canopy',
+      },
+    },
     icons: { single: 'lucide:minus', continuous: 'lucide:waypoints' },
   },
 }

package/src/lib/elevation-guides.ts

@@ -154,12 +154,27 @@ export function collectElevationSnapTargets(
         anchor: center,
         label: 'Wall base',
       })
-      targets.push({
-        id: `${node.id}:top`,
-        elevation: base + getWallEffectiveHeightForNodes(node, nodes),
-        anchor: center,
-        label: 'Wall top',
-      })
+      if (node.endHeightOffset) {
+        targets.push({
+          id: `${node.id}:top-start`,
+          elevation: base + getWallEffectiveHeightForNodes(node, nodes, 0),
+          anchor: node.start,
+          label: 'Wall top start',
+        })
+        targets.push({
+          id: `${node.id}:top-end`,
+          elevation: base + getWallEffectiveHeightForNodes(node, nodes, 1),
+          anchor: node.end,
+          label: 'Wall top end',
+        })
+      } else {
+        targets.push({
+          id: `${node.id}:top`,
+          elevation: base + getWallEffectiveHeightForNodes(node, nodes, 0.5),
+          anchor: center,
+          label: 'Wall top',
+        })
+      }
       continue
     }
 

package/src/lib/elevator-support.ts

@@ -1,26 +1,4 @@
-import {
-  type AnyNode,
-  type AnyNodeId,
-  type BuildingNode,
-  type ElevatorNode,
-  type LevelNode,
-  spatialGridManager,
-  useScene,
-} from '@pascal-app/core'
-
-function getBuildingLevels(
-  buildingId: string | null | undefined,
-  nodes: Record<string, AnyNode>,
-): LevelNode[] {
-  if (!buildingId) return []
-  const building = nodes[buildingId as AnyNodeId]
-  if (building?.type !== 'building') return []
-
-  return building.children
-    .map((childId) => nodes[childId as AnyNodeId])
-    .filter((entry): entry is LevelNode => entry?.type === 'level')
-    .sort((left, right) => left.level - right.level)
-}
+import type { AnyNode, AnyNodeId, BuildingNode, LevelNode } from '@pascal-app/core'
 
 export function resolveCurrentBuildingId({
   buildingId,
@@ -45,52 +23,3 @@ export function resolveCurrentBuildingId({
 
   return null
 }
-
-export function resolveElevatorSupportLevelId({
-  buildingId,
-  preferredLevelId,
-}: {
-  buildingId: string | null | undefined
-  preferredLevelId?: string | null
-}): LevelNode['id'] | null {
-  const nodes = useScene.getState().nodes
-  const preferred = preferredLevelId ? nodes[preferredLevelId as AnyNodeId] : undefined
-  const levels = getBuildingLevels(buildingId, nodes)
-  const preferredInBuilding = preferredLevelId
-    ? levels.find((level) => level.id === preferredLevelId)
-    : undefined
-
-  if (preferredInBuilding) return preferredInBuilding.id
-  if (levels.length === 0) return preferred?.type === 'level' ? preferred.id : null
-
-  return levels[0]?.id ?? null
-}
-
-export function resolveElevatorSupportY({
-  buildingId,
-  preferredLevelId,
-  x,
-  z,
-}: {
-  buildingId: string | null | undefined
-  preferredLevelId?: string | null
-  x: number
-  z: number
-}): number {
-  const levelId = resolveElevatorSupportLevelId({ buildingId, preferredLevelId })
-  if (!levelId) return 0
-
-  return Math.max(0, spatialGridManager.getSlabElevationAt(levelId, x, z))
-}
-
-export function resolveElevatorNodeSupportY(
-  node: ElevatorNode,
-  position: [number, number, number] = node.position,
-): number {
-  return resolveElevatorSupportY({
-    buildingId: node.parentId,
-    preferredLevelId: node.fromLevelId ?? node.defaultLevelId,
-    x: position[0],
-    z: position[2],
-  })
-}

package/src/lib/floor-footprints.test.ts

@@ -4,12 +4,14 @@ import {
   applySceneOperationPatch,
   BuildingNode,
   clearSceneHistory,
+  createI18n,
   createZone,
   floorFootprintName,
   generateId,
   ItemNode,
   initSpaceDetectionSync,
   LevelNode,
+  levelFootprints,
   type SceneCommit,
   type SlabNode,
   SlabNode as SlabSchema,
@@ -28,7 +30,6 @@ import {
   footprintsToMoveTogether,
   foundationHeight,
   isFootprintConstructionHit,
-  levelFootprints,
   presetPatch,
   roomFloorOwner,
   roomFootprint,
@@ -418,7 +419,7 @@ describe('floor footprints', () => {
     // What the notice offers instead: both footprints, together, in one step.
     const together = footprintsToMoveTogether(nodes(), house.id, patch)
     expect(together).toEqual([house.id, shed.id])
-    expect(moveTogetherLabel(together!.length, false)).toBe('Raise both')
+    expect(moveTogetherLabel(together!.length, false, createI18n())).toBe('Raise both')
     const steps = history()
     expect(applyFloorFoundation(together!, patch)).toBeNull()
     expect(history()).toBe(steps + 1)

package/src/lib/floor-footprints.ts

@@ -10,6 +10,7 @@ import {
   getRoomBaseElevation,
   groundFloorConstruction,
   intersection,
+  levelFootprints,
   roomDrawnFloor,
   type SlabNode,
   setFloorFoundation,
@@ -39,15 +40,6 @@ const ON_GROUND = 0.0005
 const isBase = (node: AnyNode | undefined): node is SlabNode =>
   node?.type === 'slab' && node.plateRole === 'base'
 
-const footprintArea = (plate: SlabNode) => area([{ outer: plate.polygon, holes: plate.holes }])
-
-/** The level's footprints, largest first (ties by id, so the order is stable). */
-export function levelFootprints(nodes: Record<string, AnyNode>, levelId: string): SlabNode[] {
-  return Object.values(nodes)
-    .filter((node): node is SlabNode => isBase(node) && node.parentId === levelId)
-    .sort((a, b) => footprintArea(b) - footprintArea(a) || a.id.localeCompare(b.id))
-}
-
 /**
  * The drawn slab a room's floor is: the one it visibly stands on (a legacy
  * floor can show a hand-drawn slab over the one it was taken from), else the

package/src/lib/floor-foundation-support.test.ts

@@ -3,6 +3,7 @@ import {
   type AnyNode,
   type AnyNodeId,
   BuildingNode,
+  createI18n,
   createZone,
   floorFootprintSupportClass,
   generateId,
@@ -10,6 +11,7 @@ import {
   getLevelElevations,
   initSpaceDetectionSync,
   LevelNode,
+  levelFootprints,
   type SlabNode,
   upperFloorHeightControl,
   useScene,
@@ -29,13 +31,14 @@ import {
   footprintHeightMinimum,
   footprintHeightPatch,
   footprintHeightValue,
-  levelFootprints,
   presetPatch,
   setFootprintHeight,
   thickFloorAdvice,
 } from './floor-footprints'
 import { applyRoomPlan } from './room-structure-commands'
 
+const english = createI18n()
+
 const GROUND = 'level_support_ground'
 const UPPER = 'level_support_upper'
 let stop = () => {}
@@ -98,8 +101,10 @@ describe('Floor & foundation support class (point 5)', () => {
   })
 
   test('the kicker says where the plate is and what it rests on', () => {
-    expect(floorPlateKicker(nodes(), plateOf(GROUND, 'Living'))).toBe('Floor plate · Ground floor')
-    expect(floorPlateKicker(nodes(), plateOf(UPPER, 'Bedroom'))).toBe(
+    expect(floorPlateKicker(nodes(), plateOf(GROUND, 'Living'), english, 'en')).toBe(
+      'Floor plate · Ground floor',
+    )
+    expect(floorPlateKicker(nodes(), plateOf(UPPER, 'Bedroom'), english, 'en')).toBe(
       'Floor plate · Floor 1 · rests on Ground floor',
     )
   })
@@ -164,7 +169,6 @@ describe('Upper-floor height drag release (round-final item 6)', () => {
     test(`a drag of ${delta} m lands on release`, () => {
       const bedroom = plateOf(UPPER, 'Bedroom')
       const start = footprintHeightValue(nodes(), bedroom)
-      const past = useScene.temporal.getState().pastStates.length
       const preview = beginFootprintHeightPreview(bedroom.id)
       expect(preview.preview(start + delta / 2)).toBeNull()
       expect(preview.preview(start + delta)).toBeNull()
@@ -172,7 +176,13 @@ describe('Upper-floor height drag release (round-final item 6)', () => {
       const after = nodes()[bedroom.id] as SlabNode
       expect(after.thickness).toBeCloseTo(bedroom.thickness + delta, 6)
       expect(footprintHeightValue(nodes(), after)).toBeCloseTo(start + delta, 6)
-      expect(useScene.temporal.getState().pastStates.length).toBe(past + 1)
+      useScene.temporal.getState().undo()
+      expect(footprintHeightValue(nodes(), nodes()[bedroom.id] as SlabNode)).toBeCloseTo(start, 6)
+      useScene.temporal.getState().redo()
+      expect(footprintHeightValue(nodes(), nodes()[bedroom.id] as SlabNode)).toBeCloseTo(
+        start + delta,
+        6,
+      )
     })
   }
 })
@@ -183,7 +193,6 @@ describe('Floor & foundation panel (point 5)', () => {
     expect(ground).toMatchObject({ upper: false, preset: 'ground', underFloor: true, minHeight: 0 })
     const upper = floorFoundationModel(nodes(), plateOf(UPPER, 'Bedroom'))
     expect(upper).toMatchObject({ upper: true, underFloor: false, thickFloor: false })
-    expect(upper.kicker).toBe('Floor plate · Floor 1 · rests on Ground floor')
   })
 
   test('on the ground the two inputs are slab thickness and foundation height; the top follows', () => {

package/src/lib/floor-opening-draft.ts

@@ -7,6 +7,7 @@ import {
   generateId,
   type LevelNode,
   type MultiPolygon,
+  roomFloorElevation,
   type StructurePlan,
   structureChangeBatch,
   useScene,
@@ -31,7 +32,6 @@ import {
 import { type FloorRegionPoint, floorRegionSnapTargets } from './floor-region-snap'
 import { beginGesture, type GestureHandle } from './gesture-lifecycle'
 import { resolveRoomAssemblyHeights } from './room-assembly-overlay'
-import { roomFloorElevation } from './room-handle-drag'
 import { sfxEmitter } from './sfx-bus'
 
 // "Cut opening": draws an opening on a room's floor (or its ceiling) with the

package/src/lib/floor-region-session.ts

@@ -7,6 +7,7 @@ import {
   ceilingRegionsOwner,
   type MultiPolygon,
   resolveCeilingHeight,
+  roomFloorElevation,
   union,
   useScene,
 } from '@pascal-app/core'
@@ -32,7 +33,6 @@ import { beginGesture, type GestureHandle } from './gesture-lifecycle'
 import { hasActivePaintMaterial } from './material-paint'
 import { isPaintErasing, usePaintRegionMode } from './paint-region-mode'
 import { addCeilingRegion, addFloorRegion } from './paint-regions'
-import { roomFloorElevation } from './room-handle-drag'
 
 // An outline drawn on one room's floor: a rectangle (press, drag, release; a
 // persistent tool also takes two clicks) or a polygon (click points, close on

package/src/lib/floorplan/dimension-drive.test.ts

@@ -26,6 +26,11 @@ describe('parseDimensionInput', () => {
     expect(parseDimensionInput('12.5', 'imperial')).toBeCloseTo(12.5 * FOOT, 9)
   })
 
+  test('decimal commas follow the scoped locale', () => {
+    expect(parseDimensionInput('2,75', 'metric', 'fr')).toBe(2.75)
+    expect(parseDimensionInput('2,75', 'metric', 'en')).toBeNull()
+  })
+
   test('rejects garbage and non-positive values', () => {
     expect(parseDimensionInput('')).toBeNull()
     expect(parseDimensionInput('abc')).toBeNull()
@@ -152,7 +157,7 @@ describe('driving a wall length', () => {
     expect(plan?.updates[0]?.data).toEqual({ start: [0, 0], end: [3.5, 0] })
   })
 
-  test('a dimension across the wall is not drivable', () => {
+  test('a dimension across the wall that ends on neither face is not drivable', () => {
     const nodes = scene()
     const resolution = resolveDimensionDrive({
       nodes,
@@ -160,7 +165,10 @@ describe('driving a wall length', () => {
       start: [1.5, -1],
       end: [1.5, 1],
     })
-    expect(resolution).toEqual({ drivable: false, reason: 'dimension is not along the wall' })
+    expect(resolution).toEqual({
+      drivable: false,
+      reason: 'dimension does not start or end on this wall',
+    })
   })
 
   test('a locked wall refuses to drive', () => {
@@ -358,3 +366,29 @@ describe('an opening width tag resizes the opening', () => {
     expect(plan?.updates).toEqual([{ id: 'win_1' as AnyNodeId, data: { width: 1.2192 } }])
   })
 })
+
+describe('a dimension across a wall slides the wall', () => {
+  test('a room width from the wall face drives the wall along its normal, away from the far end', () => {
+    // wall_a runs east along z = 0; the dimension leaves its south face for a wall 3 m south.
+    const resolution = resolveDimensionDrive({
+      nodes: scene(),
+      ownerNodeId: 'wall_a' as AnyNodeId,
+      start: [1.5, 0.075],
+      end: [1.5, 3],
+    })
+    expect(resolution).toEqual({
+      drivable: true,
+      target: { kind: 'wall-offset', wallId: 'wall_a' as AnyNodeId, direction: [0, -1] },
+    })
+  })
+
+  test('the wall end of the dimension may be either witness point', () => {
+    const resolution = resolveDimensionDrive({
+      nodes: scene(),
+      ownerNodeId: 'wall_a' as AnyNodeId,
+      start: [1.5, -4],
+      end: [1.5, -0.075],
+    })
+    expect(resolution).toMatchObject({ drivable: true, target: { direction: [0, 1] } })
+  })
+})