@pascal-app/editor 1.0.7 → 1.1.0

package/src/lib/measurements.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect, test } from 'bun:test'
-import { measurementHint, parseMeasurement } from '../index'
 import {
   buildMeasurementAngleArcPoints,
   cubicMetersToVolumeUnit,
@@ -11,16 +10,18 @@ import {
   getVolumeUnitLabel,
   linearControlValueToMeters,
   linearUnitToMeters,
+  metersToLinearUnit,
+  parseLinearMeasurementInput,
+  squareMetersToAreaUnit,
+} from '@pascal-app/core'
+import {
   MEASUREMENT_ACTIVE_COLOR,
   MEASUREMENT_DANGLING_COLOR,
-  MEASUREMENT_FLOORPLAN_COLOR,
   MEASUREMENT_PERSISTENT_COLOR,
-  measurementFloorplanPresentationColor,
   measurementPresentationColor,
-  metersToLinearUnit,
-  parseLinearMeasurementInput,
-  squareMetersToAreaUnit,
-} from './measurements'
+} from '@pascal-app/viewer'
+import { measurementHint, parseMeasurement } from '../index'
+import { MEASUREMENT_FLOORPLAN_COLOR, measurementFloorplanPresentationColor } from './measurements'
 
 describe('measurement presentation', () => {
   test('uses black at rest, indigo while active, and red for dangling references', () => {

package/src/lib/measurements.ts

@@ -1,225 +1,8 @@
-import { formatNumber, type MeasurementPoint, parseLocalizedNumber } from '@pascal-app/core'
+import { MEASUREMENT_ACTIVE_COLOR, MEASUREMENT_DANGLING_COLOR } from '@pascal-app/viewer'
 
-export type LinearUnit = 'metric' | 'imperial'
-export type MetricNotation = 'meters' | 'millimeters'
-
-export const MEASUREMENT_ACTIVE_COLOR = '#6366f1'
-export const MEASUREMENT_DANGLING_COLOR = '#dc2626'
 export const MEASUREMENT_FLOORPLAN_COLOR = '#4f46e5'
-export const MEASUREMENT_PERSISTENT_COLOR = '#111827'
-
-export function measurementPresentationColor(dangling: boolean, active: boolean): string {
-  if (dangling) return MEASUREMENT_DANGLING_COLOR
-  return active ? MEASUREMENT_ACTIVE_COLOR : MEASUREMENT_PERSISTENT_COLOR
-}
 
 export function measurementFloorplanPresentationColor(dangling: boolean, active: boolean): string {
   if (dangling) return MEASUREMENT_DANGLING_COLOR
   return active ? MEASUREMENT_ACTIVE_COLOR : MEASUREMENT_FLOORPLAN_COLOR
 }
-
-type MeasurementAngleArcOptions = {
-  radius?: number
-  sampleCount?: number
-}
-
-const ANGLE_ARC_EPSILON = 1e-9
-
-const subtractPoint = (point: MeasurementPoint, origin: MeasurementPoint): MeasurementPoint => [
-  point[0] - origin[0],
-  point[1] - origin[1],
-  point[2] - origin[2],
-]
-
-const pointLength = (point: MeasurementPoint): number => Math.hypot(...point)
-
-const scalePoint = (point: MeasurementPoint, scale: number): MeasurementPoint => [
-  point[0] * scale,
-  point[1] * scale,
-  point[2] * scale,
-]
-
-const crossPoint = (first: MeasurementPoint, second: MeasurementPoint): MeasurementPoint => [
-  first[1] * second[2] - first[2] * second[1],
-  first[2] * second[0] - first[0] * second[2],
-  first[0] * second[1] - first[1] * second[0],
-]
-
-const dotPoint = (first: MeasurementPoint, second: MeasurementPoint): number =>
-  first[0] * second[0] + first[1] * second[1] + first[2] * second[2]
-
-export function buildMeasurementAngleArcPoints(
-  start: MeasurementPoint,
-  vertex: MeasurementPoint,
-  end: MeasurementPoint,
-  options: MeasurementAngleArcOptions = {},
-): MeasurementPoint[] {
-  if (![...start, ...vertex, ...end].every(Number.isFinite)) return []
-
-  const startVector = subtractPoint(start, vertex)
-  const endVector = subtractPoint(end, vertex)
-  const startLength = pointLength(startVector)
-  const endLength = pointLength(endVector)
-  if (startLength <= ANGLE_ARC_EPSILON || endLength <= ANGLE_ARC_EPSILON) return []
-
-  const startDirection = scalePoint(startVector, 1 / startLength)
-  const endDirection = scalePoint(endVector, 1 / endLength)
-  const cosine = Math.max(-1, Math.min(1, dotPoint(startDirection, endDirection)))
-  const angle = Math.acos(cosine)
-  if (angle <= 1e-4) return []
-
-  let normal = crossPoint(startDirection, endDirection)
-  let normalLength = pointLength(normal)
-  if (normalLength <= ANGLE_ARC_EPSILON) {
-    const reference: MeasurementPoint = Math.abs(startDirection[1]) < 0.9 ? [0, 1, 0] : [1, 0, 0]
-    normal = crossPoint(startDirection, reference)
-    normalLength = pointLength(normal)
-  }
-  if (normalLength <= ANGLE_ARC_EPSILON) return []
-  normal = scalePoint(normal, 1 / normalLength)
-  const tangent = crossPoint(normal, startDirection)
-
-  const shortestSide = Math.min(startLength, endLength)
-  const preferredRadius = options.radius ?? Math.min(Math.max(shortestSide * 0.28, 0.08), 0.75)
-  const radius = Math.min(Math.max(preferredRadius, 0), shortestSide * 0.45)
-  if (radius <= ANGLE_ARC_EPSILON) return []
-
-  const sampleCount = Math.min(
-    64,
-    Math.max(4, Math.round(options.sampleCount ?? Math.max(8, (angle / Math.PI) * 32))),
-  )
-  return Array.from({ length: sampleCount + 1 }, (_, index) => {
-    const sampleAngle = angle * (index / sampleCount)
-    const direction: MeasurementPoint = [
-      startDirection[0] * Math.cos(sampleAngle) + tangent[0] * Math.sin(sampleAngle),
-      startDirection[1] * Math.cos(sampleAngle) + tangent[1] * Math.sin(sampleAngle),
-      startDirection[2] * Math.cos(sampleAngle) + tangent[2] * Math.sin(sampleAngle),
-    ]
-    return [
-      vertex[0] + direction[0] * radius,
-      vertex[1] + direction[1] * radius,
-      vertex[2] + direction[2] * radius,
-    ]
-  })
-}
-
-const METERS_PER_FOOT = 0.3048
-const FEET_PER_METER = 1 / METERS_PER_FOOT
-
-type LinearControlValueOptions = {
-  minMeters?: number
-  maxMeters?: number
-}
-
-export function metersToLinearUnit(meters: number, unit: LinearUnit): number {
-  return unit === 'imperial' ? meters * FEET_PER_METER : meters
-}
-
-export function linearUnitToMeters(value: number, unit: LinearUnit): number {
-  return unit === 'imperial' ? value * METERS_PER_FOOT : value
-}
-
-export function parseLinearMeasurementInput(
-  value: string,
-  unit: LinearUnit,
-  locale: string,
-): number | null {
-  const parsed = parseLocalizedNumber(value, locale)
-  return parsed === null ? null : linearUnitToMeters(parsed, unit)
-}
-
-export function linearControlValueToMeters(
-  value: number,
-  unit: LinearUnit,
-  options: LinearControlValueOptions = {},
-): number {
-  const meters = linearUnitToMeters(value, unit)
-  const minMeters = options.minMeters ?? Number.NEGATIVE_INFINITY
-  const maxMeters = options.maxMeters ?? Number.POSITIVE_INFINITY
-
-  return Math.min(Math.max(meters, minMeters), maxMeters)
-}
-
-export function getLinearUnitLabel(unit: LinearUnit): string {
-  return unit === 'imperial' ? 'ft' : 'm'
-}
-
-const SQUARE_FEET_PER_SQUARE_METER = FEET_PER_METER * FEET_PER_METER
-const CUBIC_FEET_PER_CUBIC_METER = SQUARE_FEET_PER_SQUARE_METER * FEET_PER_METER
-
-export function squareMetersToAreaUnit(squareMeters: number, unit: LinearUnit): number {
-  return unit === 'imperial' ? squareMeters * SQUARE_FEET_PER_SQUARE_METER : squareMeters
-}
-
-export function getAreaUnitLabel(unit: LinearUnit): string {
-  return unit === 'imperial' ? 'ft²' : 'm²'
-}
-
-export function formatAreaLabel(
-  squareMeters: number,
-  unit: LinearUnit,
-  fractionDigits = 1,
-): string {
-  if (!Number.isFinite(squareMeters)) return '--'
-
-  return `${formatNumber(squareMetersToAreaUnit(squareMeters, unit), {
-    min: fractionDigits,
-    max: fractionDigits,
-  })}${getAreaUnitLabel(unit)}`
-}
-
-export function cubicMetersToVolumeUnit(cubicMeters: number, unit: LinearUnit): number {
-  return unit === 'imperial' ? cubicMeters * CUBIC_FEET_PER_CUBIC_METER : cubicMeters
-}
-
-export function getVolumeUnitLabel(unit: LinearUnit): string {
-  return unit === 'imperial' ? 'ft³' : 'm³'
-}
-
-export function formatVolumeLabel(
-  cubicMeters: number,
-  unit: LinearUnit,
-  fractionDigits = 1,
-): string {
-  if (!Number.isFinite(cubicMeters)) return '--'
-
-  return `${formatNumber(cubicMetersToVolumeUnit(cubicMeters, unit), {
-    min: fractionDigits,
-    max: fractionDigits,
-  })}${getVolumeUnitLabel(unit)}`
-}
-
-export function formatLinearMeasurement(
-  meters: number,
-  unit: LinearUnit,
-  metricNotation: MetricNotation = 'meters',
-): string {
-  if (!Number.isFinite(meters)) return '--'
-
-  const absoluteMeters = Math.abs(meters)
-
-  if (unit === 'imperial') {
-    const feet = metersToLinearUnit(absoluteMeters, unit)
-    let wholeFeet = Math.floor(feet)
-    let inches = Math.round((feet - wholeFeet) * 12)
-    if (inches === 12) {
-      wholeFeet += 1
-      inches = 0
-    }
-
-    const sign = meters < 0 && (wholeFeet !== 0 || inches !== 0) ? '-' : ''
-
-    return `${sign}${wholeFeet}'${inches}"`
-  }
-
-  if (metricNotation === 'millimeters') {
-    const roundedMillimeters = Math.round(absoluteMeters * 1000)
-    const sign = meters < 0 && roundedMillimeters !== 0 ? '-' : ''
-    return `${sign}${formatNumber(roundedMillimeters, { max: 0 })}mm`
-  }
-
-  const roundedMeters = Number.parseFloat(absoluteMeters.toFixed(2))
-  const sign = meters < 0 && roundedMeters !== 0 ? '-' : ''
-
-  return `${sign}${formatNumber(roundedMeters, { max: 2 })}m`
-}

package/src/lib/node-action-movement.test.tsx

@@ -0,0 +1,115 @@
+import { beforeAll, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  type AnyNodeId,
+  isMoveLocked,
+  isNodeDuplicable,
+  nodeRegistry,
+  registerNode,
+  useScene,
+} from '@pascal-app/core'
+import { z } from 'zod'
+import { duplicateNodeAndPickUp } from '../components/editor/duplicate-node'
+import { classifyParticipant } from '../components/editor/group-transform-shared'
+import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
+import { canDirectMoveNode } from './direct-manipulation'
+import { createEditorApi } from './editor-api'
+import { registryMoveDisabled } from './node-action-movement'
+import { copySelectedNodesToEditorClipboard } from './scene-clipboard'
+
+// Mirrors a lean-to post: a kind-level 2D mover plus per-node move and duplicate locks.
+const KIND = 'move-lock-test'
+
+beforeAll(() => {
+  if (nodeRegistry.has(KIND)) return
+  registerNode({
+    kind: KIND,
+    schemaVersion: 1,
+    schema: z.object({ type: z.literal(KIND) }) as never,
+    category: 'structure',
+    defaults: () => ({}),
+    capabilities: {
+      movable: {
+        axes: ['x', 'z'],
+        gridSnap: true,
+        override: ({ node }) =>
+          (node as { metadata?: { locked?: boolean } }).metadata?.locked
+            ? { axes: [], gridSnap: false }
+            : null,
+      },
+      duplicable: {
+        allow: ({ node }) => !(node as { metadata?: { locked?: boolean } }).metadata?.locked,
+      },
+    },
+    floorplanMoveTarget: () => ({
+      affectedIds: [],
+      apply() {},
+      canCommit: () => false,
+      commit() {},
+    }),
+    renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+  } as AnyNodeDefinition)
+})
+
+function node(locked: boolean) {
+  return {
+    id: locked ? 'move_lock_locked' : 'move_lock_free',
+    type: KIND,
+    parentId: 'level_move_lock',
+    position: [1, 0, 2],
+    rotation: 0,
+    metadata: locked ? { locked: true } : {},
+  } as unknown as AnyNode
+}
+
+test('a per-node override lock outranks the kind-level 2D mover', () => {
+  expect(isMoveLocked(node(true))).toBe(true)
+  expect(isMoveLocked(node(false))).toBe(false)
+  expect(registryMoveDisabled(node(true))).toBe(true)
+  expect(registryMoveDisabled(node(false))).toBe(false)
+  expect(canDirectMoveNode(node(true))).toBe(false)
+})
+
+test('group pick-up leaves a locked node behind', () => {
+  const locked = node(true)
+  const free = node(false)
+  const nodes = { [locked.id]: locked, [free.id]: free }
+  expect(classifyParticipant(locked, 'level_move_lock', nodes)).toBeNull()
+  expect(classifyParticipant(free, 'level_move_lock', nodes)).toBe('scalar')
+})
+
+test('every moving-node entry refuses a locked node', () => {
+  const api = createEditorApi()
+  useEditor.getState().setMovingNode(node(true))
+  expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  api.engageMoveDrag(node(true))
+  expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  expect(useEditor.getState().placementDragMode).toBe(false)
+  api.engageMove(node(false))
+  expect(useInteractionScope.getState().scope.kind).toBe('moving')
+  useEditor.getState().setMovingNode(null)
+})
+
+test('a locked node cannot be duplicated or copied', () => {
+  const level = {
+    id: 'level_move_lock',
+    type: 'level',
+    parentId: null,
+    children: ['move_lock_locked', 'move_lock_free'],
+  } as unknown as AnyNode
+  const locked = node(true)
+  const free = node(false)
+  useScene.setState({
+    nodes: { [level.id]: level, [locked.id]: locked, [free.id]: free } as never,
+    rootNodeIds: [level.id as AnyNodeId],
+  })
+  expect(isNodeDuplicable(locked)).toBe(false)
+  expect(isNodeDuplicable(free)).toBe(true)
+  duplicateNodeAndPickUp(locked)
+  expect(Object.keys(useScene.getState().nodes)).toHaveLength(3)
+  expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  expect(copySelectedNodesToEditorClipboard([locked.id as AnyNodeId])).toBe(false)
+  expect(copySelectedNodesToEditorClipboard([free.id as AnyNodeId])).toBe(true)
+})

package/src/lib/node-action-movement.ts

@@ -4,12 +4,14 @@ import {
   cloneNodesInto,
   collectSubtree,
   isMovable,
+  isMoveLocked,
   nodeRegistry,
   useScene,
 } from '@pascal-app/core'
 import { copyCreateOps } from './fresh-planar-placement'
 
 export function registryMoveDisabled(node: AnyNode): boolean {
+  if (isMoveLocked(node)) return true
   const def = nodeRegistry.get(node.type)
   return Boolean(
     def?.capabilities.movable &&

package/src/lib/placement-metadata.ts

@@ -17,6 +17,10 @@ export function isFreshPlacementMetadata(metadata: unknown): boolean {
   return getPlacementMetadataRecord(metadata).isNew === true
 }
 
+export function stripPlacementMetadataFlags(
+  metadata: Record<string, unknown>,
+): Record<string, unknown>
+export function stripPlacementMetadataFlags(metadata: unknown): unknown
 export function stripPlacementMetadataFlags(metadata: unknown): unknown {
   if (typeof metadata !== 'object' || metadata === null || Array.isArray(metadata)) {
     return metadata

package/src/lib/point-ask/describe-target.ts

@@ -1,25 +1,23 @@
 import {
   type AnyNode,
   area,
+  formatLinearMeasurement,
+  getAreaUnitLabel,
   getScaledDimensions,
   getWallCurveLength,
   getWallEffectiveHeightForNodes,
   getWallThickness,
   type ItemNode,
+  type LinearUnit,
+  type MetricNotation,
   resolveLevelId,
   type SlabNode,
   type StairNode,
+  squareMetersToAreaUnit,
   type WallNode,
   type WindowNode,
   type ZoneNode,
 } from '@pascal-app/core'
-import {
-  formatLinearMeasurement,
-  getAreaUnitLabel,
-  type LinearUnit,
-  type MetricNotation,
-  squareMetersToAreaUnit,
-} from '../measurements'
 import type { PointKind, PointTarget } from './types'
 
 // Point and ask names what the finger is on (the owner, 8 October): the label chip and the
@@ -115,7 +113,7 @@ const roomOfWall = (nodes: Nodes, levelId: string, wallId: string) =>
 
 function wallHeight(wall: WallNode, nodes: Nodes): number {
   try {
-    const height = getWallEffectiveHeightForNodes(wall, nodes as Record<string, AnyNode>)
+    const height = getWallEffectiveHeightForNodes(wall, nodes as Record<string, AnyNode>, 0)
     if (Number.isFinite(height) && height > 0) return height
   } catch {
     // No slab election to consult in a bare scene: the wall's own height stands.

package/src/lib/point-ask/region.ts

@@ -1,4 +1,4 @@
-import { formatLinearMeasurement } from '../measurements'
+import { formatLinearMeasurement } from '@pascal-app/core'
 import type { Rect, ScreenPoint } from './types'
 
 // A region is a view, not a selection (spec 2.3, "A region is a view, not a selection"): a

package/src/lib/print-shell-compiler.ts

@@ -148,8 +148,19 @@ function preparedWallHeight(
       },
     }
   }
+  if (Math.abs(node.endHeightOffset ?? 0) > 1e-5) {
+    return {
+      height: null,
+      diagnostic: {
+        severity: 'error',
+        code: 'unsupported_wall_print_slope',
+        message: `Wall ${node.id} has a sloped top that does not yet have a canonical printable solid.`,
+        nodeIds: [node.id],
+      },
+    }
+  }
 
-  const height = getWallEffectiveHeightForNodes(node, nodes)
+  const height = getWallEffectiveHeightForNodes(node, nodes, 0)
   if (!Number.isFinite(height) || height <= 1e-7) {
     return {
       height: null,

package/src/lib/print-wall-solids.test.ts

@@ -155,6 +155,11 @@ describe('buildPrintableWallSolids', () => {
       { effectiveHeight: 2.5 },
       { [shaped.id]: shaped },
     )
+    const sloped = buildPrintableWallSolids(
+      { ...wall, endHeightOffset: 1.0 },
+      { effectiveHeight: 2.5 },
+      { [shaped.id]: shaped },
+    )
     const terrain = buildPrintableWallSolids(
       { ...wall, children: [], fillToTerrain: true },
       { effectiveHeight: 2.5 },
@@ -172,6 +177,12 @@ describe('buildPrintableWallSolids', () => {
         diagnostics: [expect.objectContaining({ code: 'unsupported_wall_print_curve' })],
       }),
     )
+    expect(sloped).toEqual(
+      expect.objectContaining({
+        status: 'blocked',
+        diagnostics: [expect.objectContaining({ code: 'unsupported_wall_print_slope' })],
+      }),
+    )
     expect(terrain).toEqual(
       expect.objectContaining({
         status: 'blocked',

package/src/lib/print-wall-solids.ts

@@ -27,6 +27,7 @@ export type PrintWallSolidDiagnostic = {
   code:
     | 'invalid_wall_print_dimensions'
     | 'unsupported_wall_print_curve'
+    | 'unsupported_wall_print_slope'
     | 'unsupported_wall_print_terrain'
     | 'unsupported_wall_print_opening_shape'
     | 'invalid_wall_print_opening'
@@ -258,6 +259,14 @@ export function buildPrintableWallSolids(
       nodeIds: [node.id],
     })
   }
+  if (Math.abs(node.endHeightOffset ?? 0) > DIMENSION_EPSILON) {
+    diagnostics.push({
+      severity: 'error',
+      code: 'unsupported_wall_print_slope',
+      message: `Sloped wall ${node.id} does not yet have a canonical printable solid.`,
+      nodeIds: [node.id],
+    })
+  }
   if (node.fillToTerrain) {
     diagnostics.push({
       severity: 'error',

package/src/lib/room-assembly-overlay.ts

@@ -77,7 +77,7 @@ export function resolveRoomAssemblyHeights(
     const wall = nodes[id]
     if (wall?.type !== 'wall') continue
     const base = getWallBaseElevationForNodes(wall, sceneNodes)
-    wallTops.set(id, getWallTop(wall, levelId, sceneNodes, base))
+    wallTops.set(id, getWallTop(wall, levelId, sceneNodes, base, 0.5))
   }
   const ceilingNode = room.ceilingId ? nodes[room.ceilingId] : undefined
   const ceiling =

package/src/lib/room-built-on.test.ts

@@ -8,6 +8,7 @@ import {
   generateId,
   initSpaceDetectionSync,
   LevelNode,
+  roomFloorElevation,
   SlabNode,
   type SlabNode as SlabNodeType,
   useScene,
@@ -24,11 +25,7 @@ import {
   setRoomRelativeFloorHeight,
   stepRoomFloorElevation,
 } from './room-construction-commands'
-import {
-  commitRoomElevation,
-  ownFloorElevationBounds,
-  roomFloorElevation,
-} from './room-handle-drag'
+import { commitRoomElevation, ownFloorElevationBounds } from './room-handle-drag'
 import { applyRoomPlan } from './room-structure-commands'
 import { showRoomNotice, useRoomTransform } from './room-transform-session'
 

package/src/lib/room-built-on.ts

@@ -1,12 +1,12 @@
 import {
   type AnyNode,
   roomFloorChoices as coreRoomFloorChoices,
+  levelFootprints,
   type PascalI18n,
   roomDrawnFloor,
   type SlabNode,
   type ZoneNode,
 } from '@pascal-app/core'
-import { levelFootprints } from './floor-footprints'
 
 // "Built on": which floor a room stands on. By default a room is part of its
 // connected footprint's shared floor (`floor.footprint` absent); a floor key
@@ -61,20 +61,6 @@ export function roomFloorChoices(nodes: Nodes, zoneId: string): PlateChoice[] {
     .map(({ key, plateId, name }) => ({ key, plateId, name }))
 }
 
-/**
- * The plate a room on a separate floor stands on alone: its height is that
- * plate's floor height (nothing else stands on it). Null for a room on the
- * shared floor or sharing its separate floor with other rooms.
- */
-export function roomOwnPlate(nodes: Nodes, zoneId: string): SlabNode | null {
-  const zone = nodes[zoneId]
-  if (!isRoom(zone) || !zone.floor?.footprint || zone.floor.support === 'open') return null
-  const plate = listingPlate(nodes, zone)
-  if (!plate) return null
-  const alone = !(plate.zoneIds ?? []).some((id) => id !== zoneId && isGroundRoom(nodes[id]))
-  return alone ? plate : null
-}
-
 /**
  * The shared floor beside a room on a separate floor, where it goes back to.
  * For a room on the shared floor, its own plate.

package/src/lib/room-construction-commands.ts

@@ -17,7 +17,9 @@ import {
   type NodeChange,
   planWallJustification,
   resolveCeilingHeight,
+  roomFloorElevation,
   roomFloorElevationFromRelative,
+  roomOwnPlate,
   roomSideFaces,
   runAsSingleSceneHistoryStep,
   type StructureConflict,
@@ -32,13 +34,12 @@ import useDeleteConfirmation, {
 } from '../store/use-delete-confirmation'
 import useEditor from '../store/use-editor'
 import { footprintHeightValue } from './floor-footprints'
-import { roomOwnPlate, roomSharedFootprint } from './room-built-on'
+import { roomSharedFootprint } from './room-built-on'
 import { roomClearPolygon, roomConstructionState, roomFloorContents } from './room-construction'
 import {
   mezzanineElevationBounds,
   ownFloorElevationBounds,
   planRoomElevation,
-  roomFloorElevation,
 } from './room-handle-drag'
 import { applyRoomPlan } from './room-structure-commands'
 import { showRoomNotice } from './room-transform-session'

package/src/lib/room-controls-phase6.test.ts

@@ -9,6 +9,7 @@ import {
   generateId,
   initSpaceDetectionSync,
   LevelNode,
+  roomFloorElevation,
   structureChangeBatch,
   useLiveNodeOverrides,
   useScene,
@@ -33,7 +34,6 @@ import {
   getActiveRoomHandleDrag,
   planRoomPush,
   previewRoomPush,
-  roomFloorElevation,
   roomPushHandles,
   runRoomHandleDrag,
   selectedWallDimensions,