@pascal-app/editor 1.0.6 → 1.1.0

package/src/lib/hud-title.ts

@@ -1,10 +1,19 @@
-import { type IconRef, nodeRegistry, type TerrainVerb } from '@pascal-app/core'
+import {
+  type IconRef,
+  type MessageDescriptor,
+  nodeRegistry,
+  type TerrainVerb,
+} from '@pascal-app/core'
+import { nodeLabelDescriptor } from '../i18n/node-messages'
 import type { ContinuationMode } from './continuation'
 import { getWallDrawVariantInfo, wallDrawVariantOf } from './wall-draw-variant'
 
 /** The contextual helper panel's header: what is in hand, and its key. */
 export type HudTitle = {
-  label: string
+  /** May use `{kind}`, filled with the translated, lower-cased name of `kind`. */
+  label: MessageDescriptor
+  /** The node kind whose display name the label refers to. */
+  kind?: { kind: string; english: string }
   icon?: IconRef
   shortcut?: string
 }
@@ -18,54 +27,63 @@ const TOOL_SHORTCUTS: Record<string, string> = {
 }
 
 export const SELECT_HUD_TITLE: HudTitle = {
-  label: 'Select',
+  label: /* i18n */ { id: 'editor.lib.hudTitle.select', message: 'Select' },
   icon: url('/icons/select.webp'),
   shortcut: 'V',
 }
-export const PAINT_HUD_TITLE: HudTitle = { label: 'Paint', icon: url('/icons/paint.webp') }
+export const PAINT_HUD_TITLE: HudTitle = {
+  label: /* i18n */ { id: 'editor.lib.hudTitle.paint', message: 'Paint' },
+  icon: url('/icons/paint.webp'),
+}
 export const ERASE_HUD_TITLE: HudTitle = {
-  label: 'Erase',
+  label: /* i18n */ { id: 'editor.lib.hudTitle.erase', message: 'Erase' },
   icon: { kind: 'iconify', name: 'lucide:eraser' },
 }
 export const PICK_MATERIAL_HUD_TITLE: HudTitle = {
-  label: 'Pick material',
+  label: /* i18n */ { id: 'editor.lib.hudTitle.pickMaterial', message: 'Pick material' },
   icon: { kind: 'iconify', name: 'lucide:pipette' },
 }
-export const ROTATE_HUD_TITLE: HudTitle = { label: 'Rotate', icon: url('/icons/rotate.webp') }
+export const ROTATE_HUD_TITLE: HudTitle = {
+  label: /* i18n */ { id: 'editor.lib.hudTitle.rotate', message: 'Rotate' },
+  icon: url('/icons/rotate.webp'),
+}
 export const MOVE_SELECTION_HUD_TITLE: HudTitle = {
-  label: 'Move selection',
+  label: /* i18n */ { id: 'editor.lib.hudTitle.moveSelection', message: 'Move selection' },
   icon: url('/icons/pan.webp'),
 }
-export const MOVE_ROOM_HUD_TITLE: HudTitle = { label: 'Move room', icon: url('/icons/room.webp') }
+export const MOVE_ROOM_HUD_TITLE: HudTitle = {
+  label: /* i18n */ { id: 'editor.lib.hudTitle.moveRoom', message: 'Move room' },
+  icon: url('/icons/room.webp'),
+}
 export const RESIZE_HUD_TITLE: HudTitle = {
-  label: 'Resize',
+  label: /* i18n */ { id: 'editor.lib.hudTitle.resize', message: 'Resize' },
   icon: url('/icons/resize.webp'),
 }
 export const DIVIDE_ROOM_HUD_TITLE: HudTitle = {
-  label: 'Divide room',
+  label: /* i18n */ { id: 'editor.lib.hudTitle.divideRoom', message: 'Divide room' },
   icon: url('/icons/divide-room.webp'),
 }
 export const MEZZANINE_HUD_TITLE: HudTitle = {
-  label: 'Mezzanine',
+  label: /* i18n */ { id: 'editor.lib.hudTitle.mezzanine', message: 'Mezzanine' },
   icon: url('/icons/mezzanine.webp'),
 }
 export const OPENING_HUD_TITLE: HudTitle = {
-  label: 'Cut opening',
+  label: /* i18n */ { id: 'editor.lib.hudTitle.cutOpening', message: 'Cut opening' },
   icon: { kind: 'iconify', name: 'lucide:square-dashed' },
 }
 export const TERRACE_HUD_TITLE: HudTitle = {
-  label: 'Terrace',
+  label: /* i18n */ { id: 'editor.lib.hudTitle.terrace', message: 'Terrace' },
   icon: url('/icons/floor.webp'),
 }
 export const SMART_MEASURE_HUD_TITLE: HudTitle = {
-  label: 'Smart measure',
+  label: /* i18n */ { id: 'editor.lib.hudTitle.smartMeasure', message: 'Smart measure' },
   icon: url('/icons/measure.webp'),
   shortcut: 'M',
 }
 
 const PAINT_REGION_LABELS = {
-  rectangle: 'Paint a rectangle',
-  polygon: 'Paint a shape',
+  rectangle: /* i18n */ { id: 'editor.lib.hudTitle.paintARectangle', message: 'Paint a rectangle' },
+  polygon: /* i18n */ { id: 'editor.lib.hudTitle.paintAShape', message: 'Paint a shape' },
 } as const
 
 export function paintRegionHudTitle(mode: keyof typeof PAINT_REGION_LABELS): HudTitle {
@@ -75,22 +93,28 @@ export function paintRegionHudTitle(mode: keyof typeof PAINT_REGION_LABELS): Hud
 export function terrainHudTitle(verb: TerrainVerb): HudTitle {
   const label =
     verb === 'raise'
-      ? 'Raise terrain'
+      ? /* i18n */ { id: 'editor.lib.hudTitle.raiseTerrain', message: 'Raise terrain' }
       : verb === 'lower'
-        ? 'Lower terrain'
+        ? /* i18n */ { id: 'editor.lib.hudTitle.lowerTerrain', message: 'Lower terrain' }
         : verb === 'flatten'
-          ? 'Level terrain'
-          : 'Smooth terrain'
+          ? /* i18n */ { id: 'editor.lib.hudTitle.levelTerrain', message: 'Level terrain' }
+          : /* i18n */ { id: 'editor.lib.hudTitle.smoothTerrain', message: 'Smooth terrain' }
   return { label, icon: url(`/icons/terrain-${verb}.webp`) }
 }
 
+const KIND_VERBS = {
+  edit: /* i18n */ { id: 'editor.lib.hudTitle.editKind', message: 'Edit {kind}' },
+  move: /* i18n */ { id: 'editor.lib.hudTitle.moveKind', message: 'Move {kind}' },
+  split: /* i18n */ { id: 'editor.lib.hudTitle.splitKind', message: 'Split {kind}' },
+} as const
+
 /** A kind's registry name and icon, optionally behind a verb ("Move door"). */
-export function nodeKindHudTitle(kind: string, verb?: string): HudTitle | null {
+export function nodeKindHudTitle(kind: string, verb?: keyof typeof KIND_VERBS): HudTitle | null {
   const presentation = nodeRegistry.get(kind)?.presentation
   if (!presentation) return null
-  const name = presentation.label
   return {
-    label: verb ? `${verb} ${name.toLowerCase()}` : name,
+    label: verb ? KIND_VERBS[verb] : nodeLabelDescriptor(kind, presentation.label),
+    kind: verb ? { kind, english: presentation.label } : undefined,
     icon: presentation.icon,
     shortcut: verb ? undefined : TOOL_SHORTCUTS[kind],
   }

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test'
-import { type AnyNode, sceneRegistry } from '@pascal-app/core'
+import { type AnyNode, DoorNode, LevelNode, sceneRegistry, WallNode } from '@pascal-app/core'
 import * as THREE from 'three'
 import { collectIfcMeshes, exportPreparedSceneToIfc, ifcFileName } from './ifc-export'
 
@@ -172,3 +172,43 @@ test('material groups retain their surface owner and semantic subpart', () => {
   geometry.dispose()
   material.dispose()
 })
+
+for (const rotationY of [0, Math.PI]) {
+  test(`IFC opening includes fixed lights and preserves leaf placement facing ${rotationY}`, () => {
+    const level = LevelNode.parse({ id: 'level_entry' })
+    const wall = WallNode.parse({
+      id: 'wall_entry',
+      parentId: level.id,
+      start: [0, 0],
+      end: [5, 0],
+      height: 3,
+      thickness: 0.2,
+    })
+    const door = DoorNode.parse({
+      id: 'door_entry',
+      parentId: wall.id,
+      wallId: wall.id,
+      position: [2.5, 1.05, 0],
+      rotation: [0, rotationY, 0],
+      width: 1,
+      height: 2.1,
+      sidelightLeft: 0.3,
+      sidelightRight: 0.5,
+      transomHeight: 0.4,
+    })
+    const { data } = exportPreparedSceneToIfc(
+      new THREE.Group(),
+      { [level.id]: level, [wall.id]: wall, [door.id]: door },
+      {},
+    )
+    expect(data).toMatch(/IFCRECTANGLEPROFILEDEF\([^\n]*,1\.8,0\.4\)/)
+    expect(data).toMatch(/IFCEXTRUDEDAREASOLID\([^\n]*,2\.5\)/)
+    expect(data).toMatch(/IFCDOOR\([^\n]*,2\.1,1\.,\.DOOR\./)
+    expect(data).toContain(
+      rotationY === 0 ? 'IFCCARTESIANPOINT((2.6,0.,0.))' : 'IFCCARTESIANPOINT((2.4,0.,0.))',
+    )
+    expect(data).toContain(
+      rotationY === 0 ? 'IFCCARTESIANPOINT((-0.1,0.,0.))' : 'IFCCARTESIANPOINT((0.1,0.,0.))',
+    )
+  })
+}

package/src/lib/inspector-card-mode.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, test } from 'bun:test'
 import {
   type InspectorCardMode,
+  openExtension,
   resolveActiveExtension,
   toggleCard,
-  toggleExtension,
 } from './inspector-card-mode'
 
 const collapsed: InspectorCardMode = { collapsed: true, activeExtensionId: null }
@@ -29,27 +29,6 @@ describe('toggleCard (chevron / header press)', () => {
   })
 })
 
-describe('toggleExtension (header icon press)', () => {
-  test('folded card opens straight into extension-only mode', () => {
-    expect(toggleExtension(collapsed, 'bones:eng')).toEqual(engineering)
-  })
-
-  test('regular expanded card swaps to extension-only mode', () => {
-    expect(toggleExtension(regular, 'bones:eng')).toEqual(engineering)
-  })
-
-  test('pressing the ACTIVE extension icon again returns to regular mode', () => {
-    expect(toggleExtension(engineering, 'bones:eng')).toEqual(regular)
-  })
-
-  test('pressing another extension icon switches extension modes directly', () => {
-    expect(toggleExtension(engineering, 'other:ext')).toEqual({
-      collapsed: false,
-      activeExtensionId: 'other:ext',
-    })
-  })
-})
-
 describe('resolveActiveExtension', () => {
   const bones = { id: 'bones:eng' }
   const other = { id: 'other:ext' }
@@ -71,20 +50,13 @@ describe('resolveActiveExtension', () => {
 })
 
 describe('full user flows (QA script)', () => {
-  test('chevron → regular only; fold; icon → extension only; icon again → regular', () => {
+  test('chevron → regular only; fold; extension action → extension only; chevron → regular', () => {
     let mode = collapsed
     mode = toggleCard(mode) // chevron
     expect(mode).toEqual(regular)
     mode = toggleCard(mode) // fold
     expect(mode).toEqual(collapsed)
-    mode = toggleExtension(mode, 'bones:eng') // bones icon
-    expect(mode).toEqual(engineering)
-    mode = toggleExtension(mode, 'bones:eng') // bones icon again
-    expect(mode).toEqual(regular)
-  })
-
-  test('extension mode exits via the chevron too', () => {
-    let mode = toggleExtension(collapsed, 'bones:eng')
+    mode = openExtension('bones:eng') // the action-menu button
     expect(mode).toEqual(engineering)
     mode = toggleCard(mode) // chevron
     expect(mode).toEqual(regular)

package/src/lib/inspector-card-mode.ts

@@ -14,9 +14,9 @@
  * - chevron / header press ({@link toggleCard}): collapsed → regular,
  *   regular → collapsed, extension → regular (exit extension mode first,
  *   stay expanded);
- * - extension icon press ({@link toggleExtension}): enters that
- *   extension's mode from anywhere (expanding a folded card); pressing
- *   the ACTIVE extension's icon again returns to regular.
+ * - an extension's action-menu button ({@link openExtension}): enters that
+ *   extension's mode from anywhere (expanding a folded card); pressed while
+ *   that extension is already showing, it keeps it showing.
  */
 
 export interface InspectorCardMode {
@@ -36,13 +36,8 @@ export function toggleCard(mode: InspectorCardMode): InspectorCardMode {
   return { collapsed: true, activeExtensionId: null }
 }
 
-/** Header extension-icon press. */
-export function toggleExtension(mode: InspectorCardMode, extensionId: string): InspectorCardMode {
-  // The active extension's icon pressed again → back to the regular controls.
-  if (!mode.collapsed && mode.activeExtensionId === extensionId) {
-    return { collapsed: false, activeExtensionId: null }
-  }
-  // Anywhere else (folded, regular, another extension) → this extension only.
+/** An extension's action-menu button: opens the card on that extension, or keeps it there. */
+export function openExtension(extensionId: string): InspectorCardMode {
   return { collapsed: false, activeExtensionId: extensionId }
 }
 

package/src/lib/inspector-expanded.test.ts

@@ -42,3 +42,16 @@ test('without usable storage the panel opens folded and expanding still works',
   useInspectorExpanded.getState().setExpanded(true)
   expect(useInspectorExpanded.getState().expanded).toBe(true)
 })
+
+test('an extension opened from the action menu expands the card; folding it forgets the extension', async () => {
+  stubStorage({ getItem: () => null, setItem: () => {} })
+  const { useInspectorExpanded } = await load()
+  useInspectorExpanded.getState().applyMode({ collapsed: false, activeExtensionId: 'bones:eng' })
+  expect(useInspectorExpanded.getState()).toMatchObject({
+    expanded: true,
+    activeExtensionId: 'bones:eng',
+  })
+  useInspectorExpanded.getState().setExpanded(false)
+  useInspectorExpanded.getState().setExpanded(true)
+  expect(useInspectorExpanded.getState().activeExtensionId).toBeNull()
+})

package/src/lib/inspector-expanded.ts

@@ -1,4 +1,5 @@
 import { create } from 'zustand'
+import type { InspectorCardMode } from './inspector-card-mode'
 
 // One choice for every right-side inspector panel (room, wall, item…): opened
 // expanded or folded to its header, kept per viewer until they fold it again.
@@ -26,11 +27,22 @@ function writeExpanded(expanded: boolean) {
 
 export const useInspectorExpanded = create<{
   expanded: boolean
+  /**
+   * The plugin inspector extension filling the expanded card (see `inspector-card-mode.ts`),
+   * shared so the action menu can open it. Not remembered: folding the card forgets it.
+   */
+  activeExtensionId: string | null
   setExpanded: (expanded: boolean) => void
+  applyMode: (mode: InspectorCardMode) => void
 }>((set) => ({
   expanded: readExpanded(),
+  activeExtensionId: null,
   setExpanded: (expanded) => {
     writeExpanded(expanded)
-    set({ expanded })
+    set(expanded ? { expanded } : { expanded, activeExtensionId: null })
+  },
+  applyMode: ({ collapsed, activeExtensionId }) => {
+    writeExpanded(!collapsed)
+    set({ expanded: !collapsed, activeExtensionId: collapsed ? null : activeExtensionId })
   },
 }))

package/src/lib/interaction/scope.ts

@@ -28,6 +28,7 @@ export type ReshapeKind =
   | 'tangent'
   // A kind's own reshape (wall 'split'): mounted from `def.affordanceTools[reshape]`.
   | 'split'
+  | 'trim'
 
 export type InteractionScope =
   | { kind: 'idle' }

package/src/lib/keyboard-pan.test.ts

@@ -111,6 +111,13 @@ test('modifier chords stay shortcuts, and typing in a field never pans', () => {
   expect(acceptsKeyboardPan(key({ target: new Input() }))).toBe(false)
 })
 
+test('Shift with W, S or D arms a tool instead of panning; Shift with A still pans', () => {
+  for (const code of ['KeyW', 'KeyS', 'KeyD'])
+    expect(acceptsKeyboardPan(key({ code, shiftKey: true }))).toBe(false)
+  expect(acceptsKeyboardPan(key({ code: 'KeyA', shiftKey: true }))).toBe(true)
+  expect(acceptsKeyboardPan(key({ code: 'KeyD' }))).toBe(true)
+})
+
 test('cruise speed scales with the visible width within fixed bounds', () => {
   expect(keyboardPanSpeed(0)).toBe(0.5)
   expect(keyboardPanSpeed(20)).toBeCloseTo(6)

package/src/lib/keyboard-pan.ts

@@ -2,6 +2,8 @@
 // move the same way. Keys match by physical position (`event.code`): the
 // cluster stays under the left hand on any layout (Z/Q/S/D on AZERTY).
 
+import { claimsKeyboardPan } from './tool-shortcuts'
+
 export type KeyboardPanState = {
   forward: boolean
   backward: boolean
@@ -79,10 +81,15 @@ export function clearKeyboardPanKeys(state: KeyboardPanState) {
   state.right = false
 }
 
-/** Pan keys are ignored with a modifier held (shortcuts) or while typing. */
+/**
+ * Pan keys are ignored with a modifier held (shortcuts), for a Shift chord that
+ * arms a tool (Shift+W window, Shift+S stairs, Shift+D door), and while typing.
+ */
 export function acceptsKeyboardPan(event: KeyboardEvent) {
   return (
-    !(event.metaKey || event.ctrlKey || event.altKey) && !isEditableKeyboardTarget(event.target)
+    !(event.metaKey || event.ctrlKey || event.altKey) &&
+    !claimsKeyboardPan(event) &&
+    !isEditableKeyboardTarget(event.target)
   )
 }
 

package/src/lib/layer-thickness.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from 'bun:test'
+import { ROOF_BUILD_UP_PRESETS, roofBuildUpDepths } from '@pascal-app/core'
+import { formatLayerDepth, formatLayerThickness } from './layer-thickness'
+
+const IN = 0.0254
+
+// The roof layers read DECK 10-3/16" beside COVERING 0.54": a covering of shingle and underlayment
+// is no exact 32nd, so it fell to decimals. Summed depths read as fractions, to the nearest 1/16".
+test('summed depths read as fractions to the 1/16", like the deck beside them', () => {
+  expect(formatLayerDepth(0.54 * IN, 'imperial')).toBe('9/16"')
+  for (const preset of ROOF_BUILD_UP_PRESETS) {
+    const { deck, covering } = roofBuildUpDepths(preset.buildUp)
+    for (const depth of [deck, covering])
+      expect(formatLayerDepth(depth, 'imperial')).toMatch(/^(\d+|\d+\/\d+|\d+-\d+\/\d+)"$/)
+  }
+  expect(formatLayerDepth(0.0137, 'metric')).toBe('13.7 mm')
+})
+
+test('a typed thickness still reads back as typed', () => {
+  expect(formatLayerThickness((7 / 16) * IN, 'imperial')).toBe('7/16"')
+  expect(formatLayerThickness(0.0111, 'imperial')).toBe('0.437"')
+})

package/src/lib/layer-thickness.ts

@@ -0,0 +1,79 @@
+import type { LinearUnit } from '@pascal-app/core'
+
+const METRES_PER_INCH = 0.0254
+
+/**
+ * Imperial-friendly thickness input. Accepts `5/8`, `5/8"`, `7/16 in`,
+ * `1-1/4"`, `1 1/2"`, `12mm`, `0.012m`. A bare number means INCHES in imperial
+ * display and MILLIMETRES in metric — layers are millimetre-scale and
+ * typing `0.0127` for half-inch board is nobody's idea of usable.
+ */
+export function parseLayerThickness(raw: string, unit: LinearUnit): number | null {
+  const text = raw.trim().toLowerCase().replace(/["”]/g, ' in ')
+  if (!text) return null
+  const explicit = /(mm|cm|m|in|ft|')\s*$/.exec(text)
+  const suffix = explicit?.[1]
+  const body = (suffix ? text.slice(0, explicit?.index) : text).trim()
+
+  // `1-1/4` / `1 1/2` / `5/8` / `0.4375`
+  const mixed = /^(\d+(?:\.\d+)?)[\s-]+(\d+)\s*\/\s*(\d+)$/.exec(body)
+  const fraction = /^(\d+)\s*\/\s*(\d+)$/.exec(body)
+  let value: number
+  if (mixed) {
+    value = Number(mixed[1]) + Number(mixed[2]) / Number(mixed[3])
+  } else if (fraction) {
+    value = Number(fraction[1]) / Number(fraction[2])
+  } else {
+    value = Number(body)
+  }
+  if (!Number.isFinite(value) || value < 0) return null
+
+  switch (suffix) {
+    case 'mm':
+      return value / 1000
+    case 'cm':
+      return value / 100
+    case 'm':
+      return value
+    case 'in':
+      return value * METRES_PER_INCH
+    case 'ft':
+    case "'":
+      return value * 12 * METRES_PER_INCH
+    default:
+      return unit === 'imperial' ? value * METRES_PER_INCH : value / 1000
+  }
+}
+
+/**
+ * An exact 32nd of an inch as its fraction, so 7/16 in (0.0111125 m) reads back as `7/16"`; any
+ * other value as decimal inches (0.0111 m is `0.437"`).
+ */
+export function formatLayerThickness(metres: number, unit: LinearUnit): string {
+  if (unit !== 'imperial') return `${Math.round(metres * 1000 * 10) / 10} mm`
+  const inchValue = metres / METRES_PER_INCH
+  const parts = Math.round(inchValue * 32)
+  if (Math.abs(inchValue * 32 - parts) > 1e-6) return `${Math.round(inchValue * 1000) / 1000}"`
+  const whole = Math.floor(parts / 32)
+  let numerator = parts % 32
+  let denominator = 32
+  while (numerator % 2 === 0 && numerator > 0) {
+    numerator /= 2
+    denominator /= 2
+  }
+  if (numerator === 0) return `${whole}"`
+  return whole > 0 ? `${whole}-${numerator}/${denominator}"` : `${numerator}/${denominator}"`
+}
+
+/**
+ * A summed depth to read, not type back (a plane's deck or covering, a ceiling's thickness): in
+ * imperial to the nearest 1/16" as a fraction, as the lumber and panels it adds up read, so a
+ * covering of 0.54" reads 9/16" beside a 10-3/16" deck.
+ */
+export function formatLayerDepth(metres: number, unit: LinearUnit): string {
+  if (unit !== 'imperial') return formatLayerThickness(metres, unit)
+  return formatLayerThickness(
+    (Math.round((metres / METRES_PER_INCH) * 16) / 16) * METRES_PER_INCH,
+    unit,
+  )
+}

package/src/lib/level-selection.test.ts

@@ -3,6 +3,7 @@ import {
   type AnyNode,
   type AnyNodeId,
   BuildingNode,
+  ElevatorNode,
   LevelNode,
   RoofNode,
   useScene,
@@ -27,10 +28,14 @@ beforeEach(() => {
     metadata: { role: 'roof' },
   })
   const roof = RoofNode.parse({ id: 'roof_main', parentId: roofLevel.id })
-  const building = BuildingNode.parse({ id: BUILDING, children: [GROUND, roofLevel.id] })
+  const elevator = ElevatorNode.parse({ id: 'elevator_lift', parentId: BUILDING })
+  const building = BuildingNode.parse({
+    id: BUILDING,
+    children: [GROUND, roofLevel.id, elevator.id],
+  })
   useScene.setState({
     nodes: Object.fromEntries(
-      [building, ground, wall, roofLevel, roof].map((node) => [node.id, node as AnyNode]),
+      [building, ground, wall, roofLevel, roof, elevator].map((node) => [node.id, node as AnyNode]),
     ),
     rootNodeIds: [BUILDING],
   } as never)
@@ -54,4 +59,15 @@ describe('selectPlacedNode', () => {
       selectedIds: ['wall_a'],
     })
   })
+
+  test('a building-parented node keeps the floor in view and adopts its building', () => {
+    useViewer.getState().resetSelection()
+    useViewer.getState().setSelection({ levelId: GROUND })
+    selectPlacedNode('elevator_lift' as AnyNodeId)
+    expect(useViewer.getState().selection).toMatchObject({
+      buildingId: BUILDING,
+      levelId: GROUND,
+      selectedIds: ['elevator_lift'],
+    })
+  })
 })

package/src/lib/level-selection.ts

@@ -1,4 +1,4 @@
-import type { AnyNodeId, BuildingNode, LevelNode } from '@pascal-app/core'
+import type { AnyNode, AnyNodeId, BuildingNode, LevelNode } from '@pascal-app/core'
 import { findLevelAncestorId, useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 
@@ -30,17 +30,40 @@ export function deleteLevelWithFallbackSelection(levelId: AnyNodeId) {
   }
 }
 
+function findBuildingAncestorId(
+  nodeId: AnyNodeId,
+  nodes: Record<string, AnyNode>,
+): BuildingNode['id'] | null {
+  let current: AnyNode | undefined = nodes[nodeId]
+  for (let guard = 0; current && guard < 16; guard++) {
+    if (current.type === 'building') return current.id
+    current = current.parentId ? nodes[current.parentId as AnyNodeId] : undefined
+  }
+  return null
+}
+
 /**
  * Selects a node a tool just made, on its own level when that is not the one in view: a roof drawn
  * over a storey's walls lands on the level above, which the editor hides while the storey is
- * selected, so selecting it there alone would leave it out of sight.
+ * selected, so selecting it there alone would leave it out of sight. A node parented to the
+ * building itself (an elevator) has no level, so the floor in view stays active when it belongs
+ * to that building.
  */
 export function selectPlacedNode(nodeId: AnyNodeId) {
-  const levelId = findLevelAncestorId(nodeId, useScene.getState().nodes)
+  const { nodes } = useScene.getState()
+  const levelId = findLevelAncestorId(nodeId, nodes) as LevelNode['id'] | null
+  const buildingId = findBuildingAncestorId(nodeId, nodes)
   const { selection, setSelection } = useViewer.getState()
-  setSelection(
-    levelId && levelId !== selection.levelId
-      ? { levelId: levelId as LevelNode['id'], selectedIds: [nodeId] }
-      : { selectedIds: [nodeId] },
-  )
+  const updates: Partial<typeof selection> = { selectedIds: [nodeId] }
+  if (buildingId && buildingId !== selection.buildingId) {
+    updates.buildingId = buildingId
+    updates.levelId =
+      levelId ??
+      (selection.levelId && findBuildingAncestorId(selection.levelId, nodes) === buildingId
+        ? selection.levelId
+        : null)
+  } else if (levelId && levelId !== selection.levelId) {
+    updates.levelId = levelId
+  }
+  setSelection(updates)
 }

package/src/lib/linear-display.ts

@@ -4,7 +4,7 @@ import {
   linearUnitToMeters,
   type MetricNotation,
   metersToLinearUnit,
-} from './measurements'
+} from '@pascal-app/core'
 
 export function getLinearDisplay(
   unit: string,

package/src/lib/live-gesture-round-trip.test.ts

@@ -6,6 +6,7 @@ import {
   createZoneDivisionContext,
   generateId,
   nodeRegistry,
+  roomFloorElevation,
   type SlabNode,
   useLiveNodeOverrides,
   useScene,
@@ -29,7 +30,6 @@ import { roomRelativeFloorHeight, stepRoomFloorElevation } from './room-construc
 import {
   commitRoomElevation,
   mezzanineEdgeHandles,
-  roomFloorElevation,
   roomPushHandles,
   runFloorplanMezzanineEdge,
   runFloorplanRoomPush,