@pascal-app/editor 1.0.7 → 1.1.1

package/src/components/editor-2d/renderers/floorplan-label-angle.test.ts

@@ -1,89 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import {
-  resolveFloorplanAnnotationLabelTransform,
-  resolveFloorplanAnnotationUpdate,
-  resolveFloorplanLabelAngle,
-  shouldUpdateFloorplanLabelRotation,
-  updateSvgFloorplanLabelOrientations,
-} from './floorplan-label-angle'
-
-describe('resolveFloorplanLabelAngle', () => {
-  test('keeps segment labels readable while preserving their screen direction', () => {
-    expect(resolveFloorplanLabelAngle(0, 0)).toBe(0)
-    expect(resolveFloorplanLabelAngle(Math.PI, 0)).toBe(0)
-    expect(resolveFloorplanLabelAngle(Math.PI / 2, 90)).toBe(-90)
-  })
-
-  test('counter-rotates aggregate labels to remain horizontal', () => {
-    expect(resolveFloorplanLabelAngle(0, 90, true)).toBe(-90)
-    expect(resolveFloorplanLabelAngle(Math.PI / 3, -35, true)).toBe(35)
-  })
-
-  test('ignores sub-degree rotation changes for annotation layout', () => {
-    expect(shouldUpdateFloorplanLabelRotation(30, 30.9)).toBe(false)
-    expect(shouldUpdateFloorplanLabelRotation(30, 31)).toBe(true)
-    expect(shouldUpdateFloorplanLabelRotation(359.5, 0.25)).toBe(false)
-  })
-
-  test('updates only label orientation while preserving its layout shift', () => {
-    expect(
-      resolveFloorplanAnnotationLabelTransform({
-        afterRotation: 'translate(0 -0.2)',
-        angleRadians: 0,
-        beforeRotation: 'translate(4 6)',
-        layoutDx: 0.5,
-        layoutDy: -0.25,
-        sceneRotationDeg: 90,
-        screenUpright: true,
-      }),
-    ).toEqual({
-      defaultTransform: 'translate(4 6) rotate(-90) translate(0 -0.2)',
-      transform: 'translate(4 6) rotate(-90) translate(0 -0.2) translate(0.5 -0.25)',
-    })
-  })
-
-  test('keeps a rotation-only update out of the full collision layout path', () => {
-    expect(
-      resolveFloorplanAnnotationUpdate({
-        layoutInputsChanged: false,
-        nextRotationDeg: 45,
-        previousRotationDeg: 30,
-      }),
-    ).toEqual({
-      resolveCollisions: false,
-      updateLabelPresentation: true,
-    })
-  })
-
-  test('runs collision layout when floor-plan scene inputs change', () => {
-    expect(
-      resolveFloorplanAnnotationUpdate({
-        layoutInputsChanged: true,
-        nextRotationDeg: 30,
-        previousRotationDeg: 30,
-      }),
-    ).toEqual({
-      resolveCollisions: true,
-      updateLabelPresentation: true,
-    })
-  })
-
-  test('updates captured label references without rediscovering the DOM', () => {
-    const attributes = new Map<string, string>([['transform', 'translate(4 6) rotate(0)']])
-    const label = {
-      dataset: {
-        floorplanAnnotationAngleRadians: '0',
-        floorplanAnnotationLayoutDx: '0.5',
-        floorplanAnnotationLayoutDy: '-0.25',
-        floorplanAnnotationScreenUpright: 'true',
-        floorplanAnnotationTransformAfterRotation: '',
-        floorplanAnnotationTransformBeforeRotation: 'translate(4 6)',
-      },
-      getAttribute: (name: string) => attributes.get(name) ?? null,
-      setAttribute: (name: string, value: string) => attributes.set(name, value),
-    } as unknown as SVGGElement
-
-    expect(updateSvgFloorplanLabelOrientations([label], 90)).toBe(1)
-    expect(attributes.get('transform')).toBe('translate(4 6) rotate(-90) translate(0.5 -0.25)')
-  })
-})

package/src/components/editor-2d/renderers/floorplan-label-angle.ts

@@ -1,106 +0,0 @@
-export function resolveFloorplanLabelAngle(
-  angleRadians: number,
-  sceneRotationDeg: number,
-  screenUpright = false,
-): number {
-  if (screenUpright) return -sceneRotationDeg
-
-  let localAngleDeg = (angleRadians * 180) / Math.PI
-  let screenAngleDeg = localAngleDeg + sceneRotationDeg
-  screenAngleDeg = ((((screenAngleDeg + 180) % 360) + 360) % 360) - 180
-  if (screenAngleDeg > 90) localAngleDeg -= 180
-  else if (screenAngleDeg <= -90) localAngleDeg += 180
-  return ((((localAngleDeg + 180) % 360) + 360) % 360) - 180
-}
-
-export function shouldUpdateFloorplanLabelRotation(
-  previousRotationDeg: number | null,
-  nextRotationDeg: number,
-  minimumDeltaDeg = 1,
-): boolean {
-  if (previousRotationDeg === null) return true
-  const deltaDeg = ((((nextRotationDeg - previousRotationDeg + 180) % 360) + 360) % 360) - 180
-  return Math.abs(deltaDeg) >= minimumDeltaDeg
-}
-
-export function resolveFloorplanAnnotationUpdate({
-  layoutInputsChanged,
-  previousRotationDeg,
-  nextRotationDeg,
-}: {
-  layoutInputsChanged: boolean
-  previousRotationDeg: number | null
-  nextRotationDeg: number
-}): {
-  resolveCollisions: boolean
-  updateLabelPresentation: boolean
-} {
-  return {
-    resolveCollisions: layoutInputsChanged,
-    updateLabelPresentation:
-      layoutInputsChanged ||
-      shouldUpdateFloorplanLabelRotation(previousRotationDeg, nextRotationDeg),
-  }
-}
-
-export function resolveFloorplanAnnotationLabelTransform({
-  angleRadians,
-  sceneRotationDeg,
-  screenUpright,
-  beforeRotation,
-  afterRotation,
-  layoutDx = 0,
-  layoutDy = 0,
-}: {
-  angleRadians: number
-  sceneRotationDeg: number
-  screenUpright: boolean
-  beforeRotation: string
-  afterRotation: string
-  layoutDx?: number
-  layoutDy?: number
-}): {
-  defaultTransform: string
-  transform: string
-} {
-  const degrees = resolveFloorplanLabelAngle(angleRadians, sceneRotationDeg, screenUpright)
-  const defaultTransform = [beforeRotation, `rotate(${degrees})`, afterRotation]
-    .filter(Boolean)
-    .join(' ')
-  return {
-    defaultTransform,
-    transform:
-      layoutDx === 0 && layoutDy === 0
-        ? defaultTransform
-        : `${defaultTransform} translate(${layoutDx} ${layoutDy})`,
-  }
-}
-
-export function updateSvgFloorplanLabelOrientations(
-  labels: Iterable<SVGGElement>,
-  sceneRotationDeg: number,
-): number {
-  let updated = 0
-
-  for (const label of labels) {
-    const angleRadians = Number(label.dataset.floorplanAnnotationAngleRadians)
-    if (!Number.isFinite(angleRadians)) continue
-
-    const { defaultTransform, transform } = resolveFloorplanAnnotationLabelTransform({
-      angleRadians,
-      sceneRotationDeg,
-      screenUpright: label.dataset.floorplanAnnotationScreenUpright === 'true',
-      beforeRotation: label.dataset.floorplanAnnotationTransformBeforeRotation ?? '',
-      afterRotation: label.dataset.floorplanAnnotationTransformAfterRotation ?? '',
-      layoutDx: Number(label.dataset.floorplanAnnotationLayoutDx ?? 0),
-      layoutDy: Number(label.dataset.floorplanAnnotationLayoutDy ?? 0),
-    })
-    if (label.getAttribute('transform') === transform) continue
-
-    label.dataset.floorplanAnnotationDefaultTransform = defaultTransform
-    label.setAttribute('transform', transform)
-    updated += 1
-  }
-
-  return updated
-}

package/src/components/editor-2d/svg-paths.ts

@@ -1,124 +0,0 @@
-'use client'
-
-import type { Point2D } from '@pascal-app/core'
-
-function toSvgX(value: number) {
-  return value
-}
-
-function toSvgY(value: number) {
-  return value
-}
-
-function toSvgPoint(point: Point2D) {
-  return {
-    x: toSvgX(point.x),
-    y: toSvgY(point.y),
-  }
-}
-
-export function formatPolygonPath(points: Point2D[], holes: Point2D[][] = []) {
-  const formatSubpath = (subpathPoints: Point2D[]) => {
-    const [firstPoint, ...restPoints] = subpathPoints
-    if (!firstPoint) {
-      return null
-    }
-
-    const firstSvgPoint = toSvgPoint(firstPoint)
-
-    return [
-      `M ${firstSvgPoint.x} ${firstSvgPoint.y}`,
-      ...restPoints.map((point) => {
-        const svgPoint = toSvgPoint(point)
-        return `L ${svgPoint.x} ${svgPoint.y}`
-      }),
-      'Z',
-    ].join(' ')
-  }
-
-  return [points, ...holes].map(formatSubpath).filter(Boolean).join(' ')
-}
-
-export function buildSvgPolylinePath(points: Point2D[]) {
-  if (points.length < 2) {
-    return null
-  }
-
-  return points
-    .map((point, index) => {
-      const svgPoint = toSvgPoint(point)
-      return `${index === 0 ? 'M' : 'L'} ${svgPoint.x} ${svgPoint.y}`
-    })
-    .join(' ')
-}
-
-export function getArcPlanPoint(center: Point2D, radius: number, angle: number): Point2D {
-  return {
-    x: center.x + Math.cos(angle) * radius,
-    y: center.y + Math.sin(angle) * radius,
-  }
-}
-
-export function buildSvgArcPath(
-  center: Point2D,
-  radius: number,
-  startAngle: number,
-  endAngle: number,
-) {
-  const start = getArcPlanPoint(center, radius, startAngle)
-  return `M ${toSvgX(start.x)} ${toSvgY(start.y)} ${svgArcCommands(center, radius, startAngle, endAngle)}`
-}
-
-export function buildSvgAnnularSectorPath(
-  center: Point2D,
-  innerRadius: number,
-  outerRadius: number,
-  startAngle: number,
-  endAngle: number,
-) {
-  const outerStart = getArcPlanPoint(center, outerRadius, startAngle)
-  const innerEnd = getArcPlanPoint(center, innerRadius, endAngle)
-  return [
-    `M ${toSvgX(outerStart.x)} ${toSvgY(outerStart.y)}`,
-    svgArcCommands(center, outerRadius, startAngle, endAngle),
-    `L ${toSvgX(innerEnd.x)} ${toSvgY(innerEnd.y)}`,
-    svgArcCommands(center, innerRadius, endAngle, startAngle),
-    'Z',
-  ].join(' ')
-}
-
-function svgArcCommands(center: Point2D, radius: number, startAngle: number, endAngle: number) {
-  const delta = endAngle - startAngle
-  const count = Math.max(1, Math.ceil(Math.abs(delta) / Math.PI))
-  return Array.from({ length: count }, (_, index) => {
-    const end = getArcPlanPoint(center, radius, startAngle + (delta * (index + 1)) / count)
-    return `A ${radius} ${radius} 0 0 ${delta >= 0 ? 1 : 0} ${toSvgX(end.x)} ${toSvgY(end.y)}`
-  }).join(' ')
-}
-
-export function formatSvgPolygonPoints(points: Point2D[]) {
-  return points.map((point) => `${toSvgX(point.x)},${toSvgY(point.y)}`).join(' ')
-}
-
-/**
- * Three points defining an arrow head — tip + two trailing barbs.
- * Returned as plain `Point2D` objects so consumers can either feed them
- * straight into `formatSvgPolygonPoints` (for SVG `points=""`) or push
- * them onto a `FloorplanGeometry.polygon.points` array. Mixing both
- * downstream paths through a string-returning helper was awkward — see
- * `nodes/src/stair/floorplan.ts` which needs the points as objects.
- */
-export function buildSvgArrowHeadPoints(point: Point2D, angle: number, size: number): Point2D[] {
-  const left = {
-    x: point.x - size * Math.cos(angle - Math.PI / 6),
-    y: point.y - size * Math.sin(angle - Math.PI / 6),
-  }
-  const right = {
-    x: point.x - size * Math.cos(angle + Math.PI / 6),
-    y: point.y - size * Math.sin(angle + Math.PI / 6),
-  }
-
-  return [point, left, right]
-}
-
-export { toSvgPoint, toSvgX, toSvgY }

package/src/components/tools/elevator/elevator-defaults.ts

@@ -1,8 +0,0 @@
-export const DEFAULT_ELEVATOR_WIDTH = 1.84
-export const DEFAULT_ELEVATOR_DEPTH = 1.84
-export const DEFAULT_ELEVATOR_CAB_HEIGHT = 2.35
-export const DEFAULT_ELEVATOR_DOOR_WIDTH = 0.95
-export const DEFAULT_ELEVATOR_DOOR_HEIGHT = 2.1
-export const DEFAULT_ELEVATOR_SPEED = 2.2
-export const DEFAULT_ELEVATOR_DOOR_DURATION_MS = 900
-export const DEFAULT_ELEVATOR_DWELL_MS = 1400

package/src/components/tools/elevator/elevator-tool.tsx

@@ -1,372 +0,0 @@
-import {
-  type AnyNodeId,
-  type BuildingNode,
-  collectAlignmentAnchors,
-  ElevatorNode,
-  emitter,
-  type GridEvent,
-  type LevelNode,
-  resolveAlignment,
-  useScene,
-} from '@pascal-app/core'
-import { useEffect, useMemo, useRef } from 'react'
-import * as THREE from 'three'
-import { resolveCurrentBuildingId, resolveElevatorSupportY } from '../../../lib/elevator-support'
-import { sfxEmitter } from '../../../lib/sfx-bus'
-import { isTypingTarget } from '../../../lib/typing-target'
-import useAlignmentGuides from '../../../store/use-alignment-guides'
-import useEditor, {
-  isAlignmentGuideActive,
-  isGridSnapActive,
-  isMagneticSnapActive,
-} from '../../../store/use-editor'
-import usePlacementPreview from '../../../store/use-placement-preview'
-import { CursorSphere } from '../shared/cursor-sphere'
-import {
-  DEFAULT_ELEVATOR_CAB_HEIGHT,
-  DEFAULT_ELEVATOR_DEPTH,
-  DEFAULT_ELEVATOR_DOOR_DURATION_MS,
-  DEFAULT_ELEVATOR_DOOR_HEIGHT,
-  DEFAULT_ELEVATOR_DOOR_WIDTH,
-  DEFAULT_ELEVATOR_DWELL_MS,
-  DEFAULT_ELEVATOR_SPEED,
-  DEFAULT_ELEVATOR_WIDTH,
-} from './elevator-defaults'
-
-const GRID_OFFSET = 0.02
-/** Figma-style alignment-snap threshold (meters), matching the move tools. */
-const ALIGNMENT_THRESHOLD_M = 0.08
-
-type ElevatorToolProps = {
-  buildingId: BuildingNode['id'] | null
-  levelId: LevelNode['id'] | null
-  onPlaced?: (elevatorId: AnyNodeId, buildingId: BuildingNode['id']) => void
-}
-
-function resolveDefaultServiceRange(
-  buildingId: BuildingNode['id'],
-  selectedLevelId: LevelNode['id'] | null,
-): {
-  defaultLevelId: LevelNode['id'] | null
-  fromLevelId: LevelNode['id'] | null
-  toLevelId: LevelNode['id'] | null
-} {
-  const nodes = useScene.getState().nodes
-  const building = nodes[buildingId as AnyNodeId]
-  if (building?.type !== 'building') {
-    return { defaultLevelId: null, fromLevelId: null, toLevelId: null }
-  }
-
-  const levels = building.children
-    .map((childId) => nodes[childId as AnyNodeId])
-    .filter((node): node is LevelNode => node?.type === 'level')
-    .sort((left, right) => left.level - right.level)
-  const selectedLevelIndex = levels.findIndex((level) => level.id === selectedLevelId)
-  const fromIndex = Math.max(selectedLevelIndex, 0)
-  const fromLevel = levels[fromIndex]
-  const toLevel = levels[Math.min(fromIndex + 1, levels.length - 1)] ?? fromLevel
-
-  return {
-    defaultLevelId: fromLevel?.id ?? null,
-    fromLevelId: fromLevel?.id ?? null,
-    toLevelId: toLevel?.id ?? fromLevel?.id ?? null,
-  }
-}
-
-function createElevatorPreviewGeometry(): THREE.BufferGeometry {
-  return new THREE.BoxGeometry(
-    DEFAULT_ELEVATOR_WIDTH,
-    DEFAULT_ELEVATOR_CAB_HEIGHT,
-    DEFAULT_ELEVATOR_DEPTH,
-  )
-}
-
-function createElevatorPreviewEdgeGeometry(): THREE.BufferGeometry {
-  return new THREE.EdgesGeometry(createElevatorPreviewGeometry())
-}
-
-function commitElevatorPlacement(
-  buildingId: BuildingNode['id'],
-  selectedLevelId: LevelNode['id'] | null,
-  x: number,
-  z: number,
-  rotation: number,
-  onPlaced: ElevatorToolProps['onPlaced'],
-): void {
-  const { createNode, nodes } = useScene.getState()
-  const elevatorCount = Object.values(nodes).filter((node) => node.type === 'elevator').length
-  const serviceRange = resolveDefaultServiceRange(buildingId, selectedLevelId)
-  const supportY = resolveElevatorSupportY({
-    buildingId,
-    preferredLevelId: serviceRange.fromLevelId ?? serviceRange.defaultLevelId,
-    x,
-    z,
-  })
-  const elevator = ElevatorNode.parse({
-    name: `Elevator ${elevatorCount + 1}`,
-    parentId: buildingId,
-    position: [x, supportY, z],
-    rotation,
-    width: DEFAULT_ELEVATOR_WIDTH,
-    depth: DEFAULT_ELEVATOR_DEPTH,
-    cabHeight: DEFAULT_ELEVATOR_CAB_HEIGHT,
-    doorWidth: DEFAULT_ELEVATOR_DOOR_WIDTH,
-    doorHeight: DEFAULT_ELEVATOR_DOOR_HEIGHT,
-    ...serviceRange,
-    speed: DEFAULT_ELEVATOR_SPEED,
-    doorDurationMs: DEFAULT_ELEVATOR_DOOR_DURATION_MS,
-    dwellMs: DEFAULT_ELEVATOR_DWELL_MS,
-  })
-
-  createNode(elevator, buildingId)
-  onPlaced?.(elevator.id as AnyNodeId, buildingId)
-  sfxEmitter.emit('sfx:structure-build')
-}
-
-export const ElevatorTool: React.FC<ElevatorToolProps> = ({ buildingId, levelId, onPlaced }) => {
-  const cursorRef = useRef<THREE.Group>(null)
-  const previewRef = useRef<THREE.Group>(null)
-  const rotationRef = useRef(0)
-  const previousGridPosRef = useRef<[number, number] | null>(null)
-  const previewGeometry = useMemo(() => createElevatorPreviewGeometry(), [])
-  const previewEdgeGeometry = useMemo(() => createElevatorPreviewEdgeGeometry(), [])
-
-  // Default-shaped elevator for the 2D floor-plan placement ghost. The 3D
-  // preview meshes below are hidden in 2D (canvas `display:none`), so this
-  // feeds `usePlacementPreview` → `FloorplanPlacementPreviewLayer`, which
-  // renders the elevator's footprint following the cursor.
-  const floorplanPreviewNode = useMemo(
-    () =>
-      ElevatorNode.parse({
-        name: 'Elevator',
-        position: [0, 0, 0],
-        rotation: 0,
-        width: DEFAULT_ELEVATOR_WIDTH,
-        depth: DEFAULT_ELEVATOR_DEPTH,
-        cabHeight: DEFAULT_ELEVATOR_CAB_HEIGHT,
-        doorWidth: DEFAULT_ELEVATOR_DOOR_WIDTH,
-        doorHeight: DEFAULT_ELEVATOR_DOOR_HEIGHT,
-      }),
-    [],
-  )
-
-  useEffect(() => {
-    const currentBuildingId = resolveCurrentBuildingId({
-      buildingId,
-      levelId,
-      nodes: useScene.getState().nodes,
-    })
-    if (!currentBuildingId) return
-
-    rotationRef.current = 0
-    if (previewRef.current) previewRef.current.rotation.y = 0
-
-    // Alignment candidates — anchors of every alignable object; refreshed
-    // after each placement. The elevator aligns by its ORIGIN point.
-    let alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, '', levelId)
-    // Snap the elevator origin onto another object's nearest real anchor and
-    // publish the guide. The probe is the RAW cursor, NOT the 0.5m-grid-snapped
-    // point: resolving against the grid point would only ever catch anchors
-    // that happen to sit on a grid line, so off-grid items (furniture, angled
-    // walls) would never surface a guide. The matched axis locks exactly to the
-    // candidate's coordinate; the other axis keeps its grid snap. Guides are
-    // published in every snapping mode (including Off); the magnetic pull toward
-    // them (applySnap) applies only in 'lines' mode.
-    const alignPoint = (
-      gridX: number,
-      gridZ: number,
-      rawX: number,
-      rawZ: number,
-      bypass: boolean,
-      applySnap: boolean,
-    ): [number, number] => {
-      if (bypass || alignmentCandidates.length === 0) {
-        useAlignmentGuides.getState().clear()
-        return [gridX, gridZ]
-      }
-      const ar = resolveAlignment({
-        moving: [{ nodeId: '__elevator-draft__', kind: 'corner', x: rawX, z: rawZ }],
-        candidates: alignmentCandidates,
-        threshold: ALIGNMENT_THRESHOLD_M,
-      })
-      if (ar.guides.length === 0) {
-        useAlignmentGuides.getState().clear()
-        return [gridX, gridZ]
-      }
-      useAlignmentGuides.getState().set(ar.guides)
-      if (!applySnap) return [gridX, gridZ]
-      let x = gridX
-      let z = gridZ
-      for (const guide of ar.guides) {
-        if (guide.axis === 'x') x = guide.coord
-        else z = guide.coord
-      }
-      return [x, z]
-    }
-
-    const onGridMove = (event: GridEvent) => {
-      // Grid snap follows the global mode (live step so the HUD chip is
-      // honest); Off keeps the raw cursor. Shift cycles the mode centrally.
-      const step = useEditor.getState().gridSnapStep
-      const [gridX, gridZ] = alignPoint(
-        isGridSnapActive()
-          ? Math.round(event.localPosition[0] / step) * step
-          : event.localPosition[0],
-        isGridSnapActive()
-          ? Math.round(event.localPosition[2] / step) * step
-          : event.localPosition[2],
-        event.localPosition[0],
-        event.localPosition[2],
-        !isAlignmentGuideActive(),
-        isMagneticSnapActive(),
-      )
-      const supportY = resolveElevatorSupportY({
-        buildingId: currentBuildingId,
-        preferredLevelId: levelId as LevelNode['id'] | null,
-        x: gridX,
-        z: gridZ,
-      })
-
-      cursorRef.current?.position.set(gridX, supportY + GRID_OFFSET, gridZ)
-      previewRef.current?.position.set(gridX, supportY + DEFAULT_ELEVATOR_CAB_HEIGHT / 2, gridZ)
-
-      // Publish the 2D floor-plan ghost at the snapped/aligned cursor.
-      usePlacementPreview.getState().set({
-        ...floorplanPreviewNode,
-        position: [gridX, supportY, gridZ],
-        rotation: rotationRef.current,
-      })
-
-      if (
-        (isGridSnapActive() || isMagneticSnapActive()) &&
-        previousGridPosRef.current &&
-        (gridX !== previousGridPosRef.current[0] || gridZ !== previousGridPosRef.current[1])
-      ) {
-        sfxEmitter.emit('sfx:grid-snap')
-      }
-
-      previousGridPosRef.current = [gridX, gridZ]
-    }
-
-    const onGridClick = (event: GridEvent) => {
-      const latestBuildingId = resolveCurrentBuildingId({
-        buildingId,
-        levelId,
-        nodes: useScene.getState().nodes,
-      })
-      if (!latestBuildingId) return
-
-      const step = useEditor.getState().gridSnapStep
-      const [gridX, gridZ] = alignPoint(
-        isGridSnapActive()
-          ? Math.round(event.localPosition[0] / step) * step
-          : event.localPosition[0],
-        isGridSnapActive()
-          ? Math.round(event.localPosition[2] / step) * step
-          : event.localPosition[2],
-        event.localPosition[0],
-        event.localPosition[2],
-        !isAlignmentGuideActive(),
-        isMagneticSnapActive(),
-      )
-      commitElevatorPlacement(
-        latestBuildingId,
-        levelId,
-        gridX,
-        gridZ,
-        rotationRef.current,
-        onPlaced,
-      )
-      alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, '', levelId)
-      useAlignmentGuides.getState().clear()
-      // The placed elevator's footprint now renders for real; drop the ghost
-      // (the next grid:move re-publishes it for the following placement).
-      usePlacementPreview.getState().clear()
-    }
-
-    const onKeyDown = (event: KeyboardEvent) => {
-      if (isTypingTarget(event.target)) return
-
-      const ROTATION_STEP = Math.PI / 4
-      let rotationDelta = 0
-      if (event.key === 'r' || event.key === 'R') rotationDelta = ROTATION_STEP
-      else if (event.key === 't' || event.key === 'T') rotationDelta = -ROTATION_STEP
-
-      if (rotationDelta !== 0) {
-        event.preventDefault()
-        sfxEmitter.emit('sfx:item-rotate')
-        rotationRef.current += rotationDelta
-        if (previewRef.current) previewRef.current.rotation.y = rotationRef.current
-        // Reflect the rotation in the 2D ghost immediately (no pointer move
-        // needed) by republishing at the last snapped cursor position.
-        const last = previousGridPosRef.current
-        if (last) {
-          usePlacementPreview.getState().set({
-            ...floorplanPreviewNode,
-            position: [last[0], 0, last[1]],
-            rotation: rotationRef.current,
-          })
-        }
-      }
-    }
-
-    emitter.on('grid:move', onGridMove)
-    emitter.on('grid:click', onGridClick)
-    window.addEventListener('keydown', onKeyDown)
-
-    return () => {
-      emitter.off('grid:move', onGridMove)
-      emitter.off('grid:click', onGridClick)
-      window.removeEventListener('keydown', onKeyDown)
-      useAlignmentGuides.getState().clear()
-      usePlacementPreview.getState().clear()
-    }
-  }, [buildingId, levelId, onPlaced, floorplanPreviewNode])
-
-  return (
-    <group>
-      <CursorSphere ref={cursorRef} />
-      <group ref={previewRef}>
-        <mesh geometry={previewGeometry}>
-          <meshStandardMaterial color="#38bdf8" depthWrite={false} opacity={0.12} transparent />
-        </mesh>
-        <lineSegments geometry={previewEdgeGeometry}>
-          <lineBasicMaterial color="#38bdf8" opacity={0.9} transparent />
-        </lineSegments>
-        <mesh
-          position={[0, -DEFAULT_ELEVATOR_CAB_HEIGHT / 2 + 0.015, 0]}
-          rotation={[-Math.PI / 2, 0, 0]}
-        >
-          <planeGeometry args={[DEFAULT_ELEVATOR_WIDTH, DEFAULT_ELEVATOR_DEPTH]} />
-          <meshBasicMaterial color="#38bdf8" opacity={0.16} transparent />
-        </mesh>
-        <mesh position={[0, 0, -DEFAULT_ELEVATOR_DEPTH / 2 - 0.01]}>
-          <planeGeometry args={[DEFAULT_ELEVATOR_WIDTH, DEFAULT_ELEVATOR_CAB_HEIGHT]} />
-          <meshBasicMaterial color="#e0f2fe" opacity={0.18} transparent />
-        </mesh>
-        <mesh
-          position={[
-            0,
-            -DEFAULT_ELEVATOR_CAB_HEIGHT / 2 + DEFAULT_ELEVATOR_DOOR_HEIGHT / 2,
-            -DEFAULT_ELEVATOR_DEPTH / 2 - 0.03,
-          ]}
-        >
-          <boxGeometry args={[DEFAULT_ELEVATOR_DOOR_WIDTH, DEFAULT_ELEVATOR_DOOR_HEIGHT, 0.035]} />
-          <meshStandardMaterial color="#e5e7eb" depthWrite={false} opacity={0.45} transparent />
-        </mesh>
-        <mesh
-          position={[
-            0,
-            -DEFAULT_ELEVATOR_CAB_HEIGHT / 2 + DEFAULT_ELEVATOR_DOOR_HEIGHT / 2,
-            -DEFAULT_ELEVATOR_DEPTH / 2 - 0.049,
-          ]}
-        >
-          <boxGeometry
-            args={[DEFAULT_ELEVATOR_DOOR_WIDTH + 0.14, DEFAULT_ELEVATOR_DOOR_HEIGHT + 0.14, 0.01]}
-          />
-          <meshBasicMaterial color="#38bdf8" opacity={0.5} transparent />
-        </mesh>
-      </group>
-    </group>
-  )
-}