@pascal-app/editor 1.0.5 → 1.0.7

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

@@ -4,6 +4,7 @@ import {
   applySceneOperationPatch,
   BuildingNode,
   clearSceneHistory,
+  createI18n,
   createZone,
   floorFootprintName,
   generateId,
@@ -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-foundation-support.test.ts

@@ -3,6 +3,7 @@ import {
   type AnyNode,
   type AnyNodeId,
   BuildingNode,
+  createI18n,
   createZone,
   floorFootprintSupportClass,
   generateId,
@@ -36,6 +37,8 @@ import {
 } 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',
     )
   })
@@ -183,7 +188,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/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] } })
+  })
+})

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

@@ -1,5 +1,5 @@
 import type { AnyNode, AnyNodeId, DoorNode, WallNode, WindowNode } from '@pascal-app/core'
-import { getLinkedWallUpdates } from '@pascal-app/core'
+import { getLinkedWallUpdates, normalizeDecimalInput } from '@pascal-app/core'
 
 /**
  * Driving dimensions — WS3.
@@ -34,8 +34,9 @@ const INCHES_PER_METER = 1 / 0.0254
 export function parseDimensionInput(
   raw: string,
   unit: 'metric' | 'imperial' = 'metric',
+  locale = 'en',
 ): number | null {
-  const text = raw.trim().toLowerCase().replace(/\s+/g, ' ')
+  const text = normalizeDecimalInput(raw, locale).trim().toLowerCase().replace(/\s+/g, ' ')
   if (!text) return null
 
   // Explicit metric suffix.
@@ -119,6 +120,17 @@ export type DimensionDriveTarget =
       openingId: AnyNodeId
       wallId: AnyNodeId
     }
+  | {
+      /**
+       * The dimension runs across the wall, from one of its faces to another
+       * wall (a room width, the outside size): the whole wall slides along
+       * its normal, its neighbours following, as a push of the wall does.
+       */
+      kind: 'wall-offset'
+      wallId: AnyNodeId
+      /** Unit vector the wall travels along when the value grows. */
+      direction: DimensionPlanPoint
+    }
 
 export type DimensionDriveResolution =
   | { drivable: true; target: DimensionDriveTarget }
@@ -173,7 +185,7 @@ function resolveWallDrive(
   const wallDirection = unit(subtract(wall.end, wall.start))
   if (!wallDirection) return { drivable: false, reason: 'degenerate wall' }
   if (Math.abs(cross(wallDirection, dimDirection)) > PARALLEL_TOLERANCE) {
-    return { drivable: false, reason: 'dimension is not along the wall' }
+    return resolveWallOffsetDrive(query, wall, wallDirection, dimDirection)
   }
   if ((wall as { curvature?: number }).curvature) {
     return { drivable: false, reason: 'curved walls are not drivable yet' }
@@ -209,6 +221,56 @@ function resolveWallDrive(
   }
 }
 
+/** How far off a wall's face a witness point may sit and still be on that wall. */
+const FACE_MATCH_TOLERANCE_M = 0.05
+
+/**
+ * A dimension square to the wall, with one end on it: typing a value slides
+ * the wall along its normal, away from the other end when the value grows.
+ */
+function resolveWallOffsetDrive(
+  query: DimensionDriveQuery,
+  wall: WallNode,
+  wallDirection: DimensionPlanPoint,
+  dimDirection: DimensionPlanPoint,
+): DimensionDriveResolution {
+  if (Math.abs(dot(wallDirection, dimDirection)) > PARALLEL_TOLERANCE) {
+    return { drivable: false, reason: 'dimension is neither along nor across the wall' }
+  }
+  if (wall.curveOffset) return { drivable: false, reason: 'curved walls are not drivable yet' }
+  const reach = (wall.thickness ?? 0.1) + FACE_MATCH_TOLERANCE_M
+  const onWall = (point: DimensionPlanPoint) =>
+    distanceToSegment(point, wall.start as DimensionPlanPoint, wall.end as DimensionPlanPoint) <=
+    reach
+  const startOn = onWall(query.start)
+  const endOn = onWall(query.end)
+  if (startOn === endOn) {
+    return { drivable: false, reason: 'dimension does not start or end on this wall' }
+  }
+  const direction = startOn
+    ? unit(subtract(query.start, query.end))
+    : unit(subtract(query.end, query.start))
+  if (!direction) return { drivable: false, reason: 'degenerate dimension' }
+  return {
+    drivable: true,
+    target: { kind: 'wall-offset', wallId: wall.id as AnyNodeId, direction },
+  }
+}
+
+function distanceToSegment(
+  point: DimensionPlanPoint,
+  start: DimensionPlanPoint,
+  end: DimensionPlanPoint,
+): number {
+  const segment = subtract(end, start)
+  const lengthSq = dot(segment, segment)
+  const t =
+    lengthSq <= 1e-12
+      ? 0
+      : Math.max(0, Math.min(1, dot(subtract(point, start), segment) / lengthSq))
+  return length(subtract(point, [start[0] + segment[0] * t, start[1] + segment[1] * t]))
+}
+
 function resolveOpeningDrive(
   query: DimensionDriveQuery,
   opening: DoorNode | WindowNode,
@@ -359,6 +421,9 @@ export function planDimensionDrive(args: {
 }): DimensionDrivePlan | null {
   const delta = args.nextLength - args.currentLength
   if (!Number.isFinite(delta) || Math.abs(delta) < 1e-9) return { updates: [], delta: 0 }
+  // A wall offset moves the wall with its junctions re-planned, bridges and
+  // all: that is the wall-push planner's job (`commitDimensionValue`).
+  if (args.target.kind === 'wall-offset') return null
 
   if (args.target.kind === 'opening-width') {
     const opening = args.nodes[args.target.openingId]

package/src/lib/floorplan/floorplan-export.test.ts

@@ -311,16 +311,27 @@ describe('floor plan export policy', () => {
       stairAnnotations: true,
     }
 
-    expect(resolveFloorplanExportAnnotationVisibility('expert', liveVisibility)).toEqual(
+    expect(resolveFloorplanExportAnnotationVisibility('expert', liveVisibility, true)).toEqual(
       liveVisibility,
     )
   })
 
+  test('exports no automatic dimensions while Display → Dimensions is off', () => {
+    expect(
+      resolveFloorplanExportAnnotationVisibility(
+        'expert',
+        DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        false,
+      ),
+    ).toEqual({ ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY, automaticDimensions: false })
+  })
+
   test('exports only model geometry and room labels in Default', () => {
     expect(
       resolveFloorplanExportAnnotationVisibility(
         'default',
         DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        true,
       ),
     ).toEqual({
       automaticDimensions: false,
@@ -700,7 +711,7 @@ describe('collectFloorplanGeometry', () => {
         'meters',
         DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
         'floor-plan',
-        'finished-faces',
+        'both',
         [enabledPluginId],
       )
 
@@ -758,7 +769,7 @@ describe('collectFloorplanGeometry', () => {
         'meters',
         DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
         'floor-plan',
-        'finished-faces',
+        'both',
         [enabledPluginId],
       )
       expect(upper.map(({ id }) => id)).toEqual(['site_overlay', 'level_upper_architecture'])
@@ -775,7 +786,7 @@ describe('collectFloorplanGeometry', () => {
         'meters',
         DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
         'floor-plan',
-        'finished-faces',
+        'both',
         [enabledPluginId],
       )
       // A hidden Site hides only its own ground and boundary; the site-scoped
@@ -790,7 +801,7 @@ describe('collectFloorplanGeometry', () => {
         'meters',
         DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
         'floor-plan',
-        'finished-faces',
+        'both',
         [enabledPluginId],
       )
       expect(structure.map(({ id }) => id)).toEqual(['level_architecture'])

package/src/lib/floorplan/floorplan-export.tsx

@@ -44,15 +44,11 @@ import { resolveNodeForDrawingType } from './drawing-coordination'
 import {
   type FloorplanMetricNotation,
   type FloorplanSchedule,
-  type FloorplanWallDimensionReference,
+  type FloorplanWallDimensionFaces,
   getFloorplanNodeExtension,
   readFloorplanGeometryMetadata,
 } from './floorplan-extension'
-import {
-  type FloorplanMode,
-  resolveFloorplanAnnotationVisibility,
-  resolveFloorplanWallDimensionReference,
-} from './floorplan-mode'
+import { type FloorplanMode, resolveFloorplanAnnotationVisibility } from './floorplan-mode'
 import { createFloorplanPdfDocument, type FloorplanPdfDocument } from './floorplan-pdfkit-document'
 import { renderFloorplanGeometryToPdfKit } from './floorplan-pdfkit-renderer'
 import { FLOORPLAN_VIEW_ROTATION_DEG } from './geometry'
@@ -131,7 +127,7 @@ const NEUTRAL_VIEW_STATE = {
 export function resolveFloorplanExportViewState(
   unit: 'metric' | 'imperial',
   metricNotation: FloorplanMetricNotation,
-  wallDimensionReference?: FloorplanWallDimensionReference,
+  wallDimensionFaces?: FloorplanWallDimensionFaces,
   automaticDimensions = true,
 ) {
   return {
@@ -139,7 +135,7 @@ export function resolveFloorplanExportViewState(
     automaticDimensions,
     unit,
     metricNotation,
-    wallDimensionReference,
+    wallDimensionFaces,
   }
 }
 
@@ -195,10 +191,7 @@ export async function exportFloorplanPdf(scope: FloorplanExportScope): Promise<v
   const annotationVisibility = resolveFloorplanExportAnnotationVisibility(
     floorplanMode,
     expertAnnotationState.visibility,
-  )
-  const wallDimensionReference = resolveFloorplanWallDimensionReference(
-    floorplanMode,
-    expertAnnotationState.wallDimensionReference,
+    expertAnnotationState.showDimensions,
   )
   const navigationAzimuth = useEditor.getState().navigationSyncPose?.azimuth
   const drawingType = useDrawingView.getState().drawingType
@@ -232,7 +225,7 @@ export async function exportFloorplanPdf(scope: FloorplanExportScope): Promise<v
         metricNotation,
         annotationVisibility,
         drawingType,
-        wallDimensionReference,
+        expertAnnotationState.wallDimensionFaces,
         installedPlugins,
       )
       const schedules = collectFloorplanSchedules(nodes, level.id, unit, scope)
@@ -604,8 +597,12 @@ export function resolveFloorplanScreenUnitsPerPixel(
 export function resolveFloorplanExportAnnotationVisibility(
   mode: FloorplanMode,
   liveVisibility: FloorplanAnnotationVisibility,
+  dimensions: boolean,
 ): FloorplanAnnotationVisibility {
-  return resolveFloorplanAnnotationVisibility(mode, liveVisibility, { target: 'export' })
+  return resolveFloorplanAnnotationVisibility(mode, liveVisibility, {
+    target: 'export',
+    dimensions,
+  })
 }
 
 export function resolveFloorplanExportRotationDeg(
@@ -785,7 +782,7 @@ export function collectFloorplanGeometry(
   metricNotation: FloorplanMetricNotation,
   annotationVisibility: FloorplanAnnotationVisibility,
   drawingType: ConstructionDrawingType,
-  wallDimensionReference: FloorplanWallDimensionReference,
+  wallDimensionFaces: FloorplanWallDimensionFaces,
   /** `undefined` = legacy scene without install state: every loaded kind draws. */
   installedPlugins: readonly string[] | undefined,
 ): ExportGeometry[] {
@@ -907,7 +904,7 @@ export function collectFloorplanGeometry(
       resolveFloorplanExportViewState(
         unit,
         metricNotation,
-        wallDimensionReference,
+        wallDimensionFaces,
         annotationVisibility.automaticDimensions,
       ),
       levelData,

package/src/lib/floorplan/floorplan-extension.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from 'bun:test'
 import type { GeometryContext } from '@pascal-app/core'
 import {
   createFloorplanContextExtensions,
-  normalizeFloorplanWallDimensionReference,
+  normalizeFloorplanWallDimensionFaces,
   readFloorplanContext,
 } from './floorplan-extension'
 
@@ -17,22 +17,21 @@ function context(extensions?: Readonly<Record<string, unknown>>): GeometryContex
 }
 
 describe('floor-plan context extensions', () => {
-  test('defaults wall dimensions to finished faces', () => {
-    expect(readFloorplanContext(context()).wallDimensionReference).toBe('finished-faces')
+  test('measures walls to both faces by default', () => {
+    expect(readFloorplanContext(context()).wallDimensionFaces).toBe('both')
   })
 
-  test('carries the selected centerline or stud-face reference', () => {
-    for (const wallDimensionReference of ['centerline', 'stud-faces'] as const) {
-      const extensions = createFloorplanContextExtensions({ wallDimensionReference })
-      expect(readFloorplanContext(context(extensions)).wallDimensionReference).toBe(
-        wallDimensionReference,
-      )
+  test('carries the Measure walls choice', () => {
+    for (const wallDimensionFaces of ['interior', 'exterior', 'both'] as const) {
+      const extensions = createFloorplanContextExtensions({ wallDimensionFaces })
+      expect(readFloorplanContext(context(extensions)).wallDimensionFaces).toBe(wallDimensionFaces)
     }
   })
 
-  test('normalizes stale persisted references to the finished-face default', () => {
-    expect(normalizeFloorplanWallDimensionReference('unknown')).toBe('finished-faces')
-    expect(normalizeFloorplanWallDimensionReference(null)).toBe('finished-faces')
+  test('normalizes stale persisted values, including the retired references, to Both', () => {
+    for (const stale of ['finished-faces', 'centerline', 'stud-faces', 'unknown', null]) {
+      expect(normalizeFloorplanWallDimensionFaces(stale)).toBe('both')
+    }
   })
 
   test('lets presentation code suppress automatic annotation construction', () => {

package/src/lib/floorplan/floorplan-extension.ts

@@ -8,6 +8,7 @@ import type {
   SceneApi,
 } from '@pascal-app/core'
 import type { ComponentType } from 'react'
+import type { WallSelectionDimension } from '../room-push-dimensions'
 
 export const FLOORPLAN_NODE_EXTENSION_KEY = 'pascal:editor/floorplan'
 export const FLOORPLAN_GEOMETRY_METADATA_KEY = 'pascal:editor/floorplan'
@@ -16,8 +17,20 @@ export const FLOORPLAN_CONTEXT_EXTENSION_KEY = 'pascal:editor/floorplan'
 export type FloorplanRenderPurpose = 'edit' | 'document'
 export type FloorplanMetricNotation = 'meters' | 'millimeters'
 export type FloorplanToolMode = 'default' | 'expert'
-export type FloorplanWallDimensionReference = 'finished-faces' | 'centerline' | 'stud-faces'
-export const DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE = 'finished-faces'
+/**
+ * Display → Measure walls: which finished faces wall dimensions measure to —
+ * the interior faces (ID, the room sizes), the exterior faces (OD, the
+ * outside size) or both. Read by a selected wall's temporary dimensions in 2D
+ * and 3D and by the Expert plan's automatic dimension strings.
+ */
+export type FloorplanWallDimensionFaces = 'interior' | 'exterior' | 'both'
+export const DEFAULT_FLOORPLAN_WALL_DIMENSION_FACES: FloorplanWallDimensionFaces = 'both'
+
+export function normalizeFloorplanWallDimensionFaces(value: unknown): FloorplanWallDimensionFaces {
+  return value === 'interior' || value === 'exterior'
+    ? value
+    : DEFAULT_FLOORPLAN_WALL_DIMENSION_FACES
+}
 export type FloorplanAnnotationRole =
   | 'automatic-dimension'
   | 'contextual-dimension'
@@ -67,6 +80,24 @@ export type FloorplanNodeExtension<N extends AnyNode = AnyNode> = {
   preferredView?: '2d' | '3d'
   referencedSelectionAnnotationRole?: FloorplanAnnotationRole
   contextualDimensions?: (node: N, ctx: GeometryContext) => FloorplanGeometry | null
+  /**
+   * A plan hit on this kind selects the node itself, not the room it bounds
+   * (3D stays room-first). For thin boundary bands whose rooms are clickable
+   * on either side of them.
+   */
+  planHitSelectsNode?: boolean
+  /**
+   * Temporary dimensions shown while this node is selected in Select mode,
+   * alone or with others, in 2D and 3D (level-local plan points). Its
+   * `contextualDimensions` also stay in a multi-selection. Each is typeable:
+   * `commitDimensionValue` drives the node so it reads the typed value.
+   * Recomputed when the node or its level's rooms change.
+   */
+  selectionDimensions?: (args: {
+    node: N
+    nodes: Readonly<Record<AnyNodeId, AnyNode>>
+    faces: FloorplanWallDimensionFaces
+  }) => readonly WallSelectionDimension[]
   actionMenu?: {
     canCurve?: (args: { node: N; nodes: Readonly<Record<AnyNodeId, AnyNode>> }) => boolean
     /** Buttons the kind adds to the selection's action menu (2D and 3D); each decides its own visibility. */
@@ -130,15 +161,7 @@ type FloorplanContextExtension = {
    */
   roomLabelOverlay: boolean
   metricNotation: FloorplanMetricNotation
-  wallDimensionReference: FloorplanWallDimensionReference
-}
-
-export function normalizeFloorplanWallDimensionReference(
-  value: unknown,
-): FloorplanWallDimensionReference {
-  return value === 'centerline' || value === 'stud-faces'
-    ? value
-    : DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE
+  wallDimensionFaces: FloorplanWallDimensionFaces
 }
 
 export function getFloorplanNodeExtension(
@@ -185,9 +208,7 @@ export function createFloorplanContextExtensions(
       drafting: values.drafting === true,
       roomLabelOverlay: values.roomLabelOverlay === true,
       metricNotation: values.metricNotation === 'millimeters' ? 'millimeters' : 'meters',
-      wallDimensionReference: normalizeFloorplanWallDimensionReference(
-        values.wallDimensionReference,
-      ),
+      wallDimensionFaces: normalizeFloorplanWallDimensionFaces(values.wallDimensionFaces),
     } satisfies FloorplanContextExtension,
   }
 }
@@ -202,9 +223,7 @@ export function readFloorplanContext(ctx: GeometryContext): FloorplanContextExte
       drafting: extension.drafting === true,
       roomLabelOverlay: extension.roomLabelOverlay === true,
       metricNotation: extension.metricNotation === 'millimeters' ? 'millimeters' : 'meters',
-      wallDimensionReference: normalizeFloorplanWallDimensionReference(
-        extension.wallDimensionReference,
-      ),
+      wallDimensionFaces: normalizeFloorplanWallDimensionFaces(extension.wallDimensionFaces),
     }
   }
   return {
@@ -213,7 +232,7 @@ export function readFloorplanContext(ctx: GeometryContext): FloorplanContextExte
     drafting: false,
     roomLabelOverlay: false,
     metricNotation: 'meters',
-    wallDimensionReference: DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE,
+    wallDimensionFaces: DEFAULT_FLOORPLAN_WALL_DIMENSION_FACES,
   }
 }
 

package/src/lib/floorplan/floorplan-mode.test.ts

@@ -5,7 +5,6 @@ import {
   normalizeFloorplanMode,
   normalizeFloorplanModesByProject,
   resolveFloorplanAnnotationVisibility,
-  resolveFloorplanWallDimensionReference,
 } from './floorplan-mode'
 
 describe('floor-plan mode', () => {
@@ -115,10 +114,18 @@ describe('floor-plan mode', () => {
     })
   })
 
-  test('uses centerline dimensions only in Default', () => {
-    expect(resolveFloorplanWallDimensionReference('default', 'finished-faces')).toBe('centerline')
-    expect(resolveFloorplanWallDimensionReference('expert', 'finished-faces')).toBe(
-      'finished-faces',
-    )
+  test('Dimensions off hides automatic and contextual dimensions in both modes', () => {
+    for (const mode of ['default', 'expert'] as const) {
+      const visibility = resolveFloorplanAnnotationVisibility(
+        mode,
+        { ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY, contextualDimensions: true },
+        { selected: true, target: 'editor', dimensions: false },
+      )
+      expect(visibility.automaticDimensions).toBe(false)
+      expect(visibility.contextualDimensions).toBe(false)
+      // Drawn dimensions and measurements are the user's own: they stay.
+      expect(visibility.manualDimensions).toBe(true)
+      expect(visibility.measurements).toBe(true)
+    }
   })
 })

package/src/lib/floorplan/floorplan-mode.ts

@@ -2,11 +2,7 @@ import {
   type FloorplanAnnotationVisibility,
   revealFloorplanAnnotationRole,
 } from './annotation-visibility'
-import type {
-  FloorplanAnnotationRole,
-  FloorplanToolMode,
-  FloorplanWallDimensionReference,
-} from './floorplan-extension'
+import type { FloorplanAnnotationRole, FloorplanToolMode } from './floorplan-extension'
 
 export const FLOORPLAN_MODES = ['default', 'expert'] as const
 
@@ -18,6 +14,8 @@ export type FloorplanPresentationContext = {
   referencedAnnotationRole?: FloorplanAnnotationRole
   selected?: boolean
   target: 'editor' | 'export'
+  /** Display → Dimensions. Off hides the automatic and contextual dimensions in either mode. */
+  dimensions?: boolean
 }
 
 export function normalizeFloorplanMode(value: unknown): FloorplanMode {
@@ -45,6 +43,17 @@ export function resolveFloorplanAnnotationVisibility(
   mode: FloorplanMode,
   expertVisibility: FloorplanAnnotationVisibility,
   context: FloorplanPresentationContext,
+): FloorplanAnnotationVisibility {
+  const visibility = resolveModeAnnotationVisibility(mode, expertVisibility, context)
+  if (context.dimensions !== false) return visibility
+  if (!visibility.automaticDimensions && !visibility.contextualDimensions) return visibility
+  return { ...visibility, automaticDimensions: false, contextualDimensions: false }
+}
+
+function resolveModeAnnotationVisibility(
+  mode: FloorplanMode,
+  expertVisibility: FloorplanAnnotationVisibility,
+  context: FloorplanPresentationContext,
 ): FloorplanAnnotationVisibility {
   if (mode === 'expert') return expertVisibility
 
@@ -66,10 +75,3 @@ export function resolveFloorplanAnnotationVisibility(
     ? revealFloorplanAnnotationRole(visibility, context.referencedAnnotationRole)
     : visibility
 }
-
-export function resolveFloorplanWallDimensionReference(
-  mode: FloorplanMode,
-  expertReference: FloorplanWallDimensionReference,
-): FloorplanWallDimensionReference {
-  return mode === 'default' ? 'centerline' : expertReference
-}

package/src/lib/floorplan/floorplan-plugin-install.test.tsx

@@ -90,7 +90,7 @@ function exportedIds(installedPlugins: readonly string[] | undefined) {
     'meters',
     DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
     'floor-plan',
-    'finished-faces',
+    'both',
     installedPlugins,
   ).map(({ id }) => id)
 }

package/src/lib/floorplan/floorplan-readonly.ts

@@ -1,7 +1,7 @@
 import type { AnyNode, AnyNodeId, FloorplanPalette, GeometryContext } from '@pascal-app/core'
 import {
   createFloorplanContextExtensions,
-  type FloorplanWallDimensionReference,
+  type FloorplanWallDimensionFaces,
 } from './floorplan-extension'
 
 export type FloorplanViewState = {
@@ -14,7 +14,7 @@ export type FloorplanViewState = {
   drafting?: boolean
   /** Room labels drawn as screen pills (see `FloorplanContextExtension.roomLabelOverlay`). */
   roomLabelOverlay?: boolean
-  wallDimensionReference?: FloorplanWallDimensionReference
+  wallDimensionFaces?: FloorplanWallDimensionFaces
   highlighted: boolean
   hovered: boolean
   moving: boolean
@@ -65,7 +65,7 @@ export function buildFloorplanContext(
       purpose: viewState.purpose ?? 'edit',
       drafting: viewState.drafting === true,
       roomLabelOverlay: viewState.roomLabelOverlay === true,
-      wallDimensionReference: viewState.wallDimensionReference,
+      wallDimensionFaces: viewState.wallDimensionFaces,
     }),
     viewState: viewState.palette
       ? {