@pascal-app/editor 0.8.0 → 0.9.2

package/src/lib/surface-plan-snap.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from 'bun:test'
+import type { AnyNode, WallNode } from '@pascal-app/core'
+import { resolveSurfacePlanPointSnap } from './surface-plan-snap'
+
+const wall = (id: string, start: [number, number], end: [number, number]): WallNode =>
+  ({
+    id,
+    type: 'wall',
+    start,
+    end,
+    visible: true,
+  }) as WallNode
+
+const nodesOf = (...walls: WallNode[]): Record<string, AnyNode> =>
+  Object.fromEntries(walls.map((node) => [node.id, node as AnyNode]))
+
+// The measurement tool passes `magnetic` explicitly so its snapping never
+// depends on the construction snapping-mode chip (whose default 'grid' mode
+// turns `isMagneticSnapActive()` off). These tests pin that seam.
+describe('resolveSurfacePlanPointSnap magnetic override', () => {
+  const walls = [wall('wall-a', [0, 0], [4, 0]), wall('wall-b', [0, 0], [0, 4])]
+  const nodes = nodesOf(...walls)
+
+  test('magnetic: true acquires a shared wall corner from the full endpoint radius', () => {
+    const result = resolveSurfacePlanPointSnap({
+      rawPoint: [0.3, 0.2],
+      nodes,
+      magnetic: true,
+      align: false,
+    })
+    expect(result.point).toEqual([0, 0])
+    expect(result.wallSnap).toBe('endpoint')
+    expect(result.wallIds.sort()).toEqual(['wall-a', 'wall-b'])
+  })
+
+  test('magnetic: true acquires a T-junction crossing on a wall body', () => {
+    const crossing = [wall('wall-a', [0, 0], [4, 0]), wall('wall-c', [3, -1], [3, 3])]
+    const result = resolveSurfacePlanPointSnap({
+      rawPoint: [3.05, 0.1],
+      nodes: nodesOf(...crossing),
+      magnetic: true,
+      align: false,
+    })
+    expect(result.point).toEqual([3, 0])
+    expect(result.wallSnap).toBe('intersection')
+  })
+
+  test('magnetic: false keeps the fallback point outside the tight connect radius', () => {
+    const result = resolveSurfacePlanPointSnap({
+      rawPoint: [0.3, 0.2],
+      fallbackPoint: [0.3, 0.2],
+      nodes,
+      magnetic: false,
+      align: false,
+    })
+    expect(result.point).toEqual([0.3, 0.2])
+    expect(result.wallSnap).toBeNull()
+  })
+
+  test('magnetic: false still sticks within the connect radius so ends can meet', () => {
+    const result = resolveSurfacePlanPointSnap({
+      rawPoint: [0.03, 0.02],
+      fallbackPoint: [0.03, 0.02],
+      nodes,
+      magnetic: false,
+      align: false,
+    })
+    expect(result.point).toEqual([0, 0])
+    expect(result.wallSnap).toBe('endpoint')
+  })
+})

package/src/lib/surface-plan-snap.ts

@@ -0,0 +1,256 @@
+import {
+  type AlignmentAnchor,
+  type AlignmentGuide,
+  type AnyNode,
+  collectAlignmentAnchors,
+  getWallCurveFrameAt,
+  getWallCurveLength,
+  isCurvedWall,
+  resolveLevelId,
+  useScene,
+  type WallNode,
+} from '@pascal-app/core'
+import {
+  getSegmentGridStep,
+  snapWallDraftPointDetailed,
+  WALL_CONNECT_SNAP_RADIUS,
+  type WallDraftSnapKind,
+  type WallPlanPoint,
+  type WallSnapRadii,
+} from '../components/tools/wall/wall-drafting'
+import useAlignmentGuides from '../store/use-alignment-guides'
+import { isMagneticSnapActive } from '../store/use-editor'
+import useWallSnapIndicator from '../store/use-wall-snap-indicator'
+import { resolveAlignmentForFloorplanView } from './world-grid-snap'
+
+const SURFACE_SNAP_MOVING_ID = '__surface_snap__'
+export const SURFACE_ALIGNMENT_THRESHOLD_M = 0.08
+const SURFACE_WALL_SNAP_RADII = {
+  endpoint: 0.38,
+  midpoint: 0.28,
+  intersection: 0.28,
+  wall: 0.18,
+} satisfies WallSnapRadii
+const WALL_SOURCE_MATCH_EPSILON = 0.035
+
+export type SurfacePlanSnapInput = {
+  rawPoint: WallPlanPoint
+  fallbackPoint?: WallPlanPoint
+  levelId?: string | null
+  excludeId?: string | null
+  movingId?: string
+  nodes?: Readonly<Record<string, AnyNode>>
+  walls?: readonly WallNode[]
+  candidates?: readonly AlignmentAnchor[]
+  threshold?: number
+  magnetic?: boolean
+  align?: boolean
+  highlightWalls?: boolean
+  step?: number
+  snapRadii?: WallSnapRadii
+}
+
+export type SurfacePlanSnapResult = {
+  point: WallPlanPoint
+  wallSnap: WallDraftSnapKind | null
+  guides: AlignmentGuide[]
+  wallIds: string[]
+}
+
+export function getLevelWalls(
+  nodes: Readonly<Record<string, AnyNode>>,
+  levelId: string | null | undefined,
+  walls?: readonly WallNode[],
+): WallNode[] {
+  const source =
+    walls ?? Object.values(nodes).filter((node): node is WallNode => node.type === 'wall')
+  if (!levelId) return source.filter((wall) => wall.visible !== false)
+
+  return source.filter(
+    (wall) =>
+      wall.visible !== false && resolveLevelId(wall, nodes as Record<string, AnyNode>) === levelId,
+  )
+}
+
+function distanceSquared(a: WallPlanPoint, b: WallPlanPoint) {
+  const dx = a[0] - b[0]
+  const dz = a[1] - b[1]
+  return dx * dx + dz * dz
+}
+
+function wallMidpoint(wall: WallNode): WallPlanPoint {
+  if (isCurvedWall(wall)) {
+    const frame = getWallCurveFrameAt(wall, 0.5)
+    return [frame.point.x, frame.point.y]
+  }
+  return [(wall.start[0] + wall.end[0]) / 2, (wall.start[1] + wall.end[1]) / 2]
+}
+
+function distanceToSegmentSquared(point: WallPlanPoint, start: WallPlanPoint, end: WallPlanPoint) {
+  const dx = end[0] - start[0]
+  const dz = end[1] - start[1]
+  const lengthSquared = dx * dx + dz * dz
+  if (lengthSquared < 1e-9) return distanceSquared(point, start)
+
+  const t = Math.max(
+    0,
+    Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / lengthSquared),
+  )
+  const projected: WallPlanPoint = [start[0] + dx * t, start[1] + dz * t]
+  return distanceSquared(point, projected)
+}
+
+function distanceToWallSquared(point: WallPlanPoint, wall: WallNode) {
+  if (!isCurvedWall(wall)) {
+    return distanceToSegmentSquared(point, wall.start, wall.end)
+  }
+
+  const sampleCount = Math.max(8, Math.ceil(getWallCurveLength(wall) / 0.3))
+  let bestDistanceSquared = Number.POSITIVE_INFINITY
+  let previous = getWallCurveFrameAt(wall, 0).point
+  for (let index = 1; index <= sampleCount; index += 1) {
+    const current = getWallCurveFrameAt(wall, index / sampleCount).point
+    const distance = distanceToSegmentSquared(
+      point,
+      [previous.x, previous.y],
+      [current.x, current.y],
+    )
+    bestDistanceSquared = Math.min(bestDistanceSquared, distance)
+    previous = current
+  }
+  return bestDistanceSquared
+}
+
+function closestWallIds(point: WallPlanPoint, walls: readonly WallNode[], count: number) {
+  return walls
+    .map((wall) => ({ id: wall.id, distance: distanceToWallSquared(point, wall) }))
+    .sort((a, b) => a.distance - b.distance)
+    .slice(0, count)
+    .map(({ id }) => id)
+}
+
+function findSnapSourceWallIds(
+  point: WallPlanPoint,
+  kind: WallDraftSnapKind,
+  walls: readonly WallNode[],
+): string[] {
+  const epsilonSquared = WALL_SOURCE_MATCH_EPSILON ** 2
+
+  if (kind === 'endpoint') {
+    const endpointMatches = walls.filter(
+      (wall) =>
+        distanceSquared(point, wall.start) <= epsilonSquared ||
+        distanceSquared(point, wall.end) <= epsilonSquared,
+    )
+    if (endpointMatches.length > 0) return endpointMatches.map((wall) => wall.id)
+    return closestWallIds(point, walls, 1)
+  }
+
+  if (kind === 'midpoint') {
+    const midpointMatches = walls.filter(
+      (wall) => distanceSquared(point, wallMidpoint(wall)) <= epsilonSquared,
+    )
+    if (midpointMatches.length > 0) return midpointMatches.map((wall) => wall.id)
+    return closestWallIds(point, walls, 1)
+  }
+
+  if (kind === 'intersection') {
+    const crossingMatches = walls.filter(
+      (wall) => distanceToWallSquared(point, wall) <= epsilonSquared,
+    )
+    if (crossingMatches.length > 0) return crossingMatches.map((wall) => wall.id).slice(0, 2)
+    return closestWallIds(point, walls, 2)
+  }
+
+  return closestWallIds(point, walls, 1)
+}
+
+export function clearSurfacePlanSnapFeedback() {
+  useAlignmentGuides.getState().clear()
+  useWallSnapIndicator.getState().clear()
+}
+
+export function resolveSurfacePlanPointSnap(input: SurfacePlanSnapInput): SurfacePlanSnapResult {
+  const nodes = input.nodes ?? useScene.getState().nodes
+  const walls = getLevelWalls(nodes, input.levelId, input.walls)
+  const fallbackPoint = input.fallbackPoint
+  const magnetic = input.magnetic ?? isMagneticSnapActive()
+
+  const wallSnap = snapWallDraftPointDetailed({
+    point: input.rawPoint,
+    walls,
+    step: input.step ?? getSegmentGridStep(),
+    magnetic,
+    snapRadii: input.snapRadii ?? SURFACE_WALL_SNAP_RADII,
+    gridSnap: fallbackPoint ? () => fallbackPoint : undefined,
+  })
+
+  if (wallSnap.snap) {
+    const wallIds =
+      input.highlightWalls === false
+        ? []
+        : findSnapSourceWallIds(wallSnap.point, wallSnap.snap, walls)
+    useWallSnapIndicator.getState().set({
+      x: wallSnap.point[0],
+      z: wallSnap.point[1],
+      kind: wallSnap.snap,
+      ...(wallIds.length > 0 ? { wallIds } : {}),
+    })
+    useAlignmentGuides.getState().clear()
+    return { point: wallSnap.point, wallSnap: wallSnap.snap, guides: [], wallIds }
+  }
+
+  useWallSnapIndicator.getState().clear()
+
+  // Alignment "lines" are DISPLAYED in every mode (grid / lines / angles /
+  // off); the magnetic pull onto an axis is applied only when magnetic
+  // ('lines'). `align: false` fully bypasses (no guides).
+  const basePoint = fallbackPoint ?? wallSnap.point
+  if (input.align === false) {
+    useAlignmentGuides.getState().clear()
+    return { point: basePoint, wallSnap: null, guides: [], wallIds: [] }
+  }
+
+  const movingId = input.movingId ?? SURFACE_SNAP_MOVING_ID
+  const allCandidates =
+    input.candidates ??
+    collectAlignmentAnchors(nodes, input.excludeId ?? movingId, input.levelId ?? null)
+
+  // In non-magnetic modes nothing pulls the point onto a guide, so restrict
+  // alignment to anchors already within connect distance — a corner then reads
+  // no differently from any other nearby point, and far corners stop lighting up
+  // from across the plan. Magnetic ('lines') keeps the full-range guides since
+  // its snap closes the gap. Mirrors the wall draft/endpoint tools. Filtering the
+  // candidates (both local-frame, like `basePoint`) rather than the resolved
+  // guides avoids the floor-plan view rotation baked into the guide coords.
+  const candidates = magnetic
+    ? allCandidates
+    : allCandidates.filter(
+        (candidate) =>
+          distanceSquared(basePoint, [candidate.x, candidate.z]) <= WALL_CONNECT_SNAP_RADIUS ** 2,
+      )
+
+  if (candidates.length === 0) {
+    useAlignmentGuides.getState().clear()
+    return { point: basePoint, wallSnap: null, guides: [], wallIds: [] }
+  }
+
+  const alignment = resolveAlignmentForFloorplanView({
+    moving: [{ nodeId: movingId, kind: 'corner', x: basePoint[0], z: basePoint[1] }],
+    candidates,
+    threshold: input.threshold ?? SURFACE_ALIGNMENT_THRESHOLD_M,
+  })
+
+  useAlignmentGuides.getState().set(alignment.guides)
+
+  if (!alignment.snap || !magnetic) {
+    return { point: basePoint, wallSnap: null, guides: alignment.guides, wallIds: [] }
+  }
+
+  return {
+    point: [basePoint[0] + alignment.snap.dx, basePoint[1] + alignment.snap.dz],
+    wallSnap: null,
+    guides: alignment.guides,
+    wallIds: [],
+  }
+}

package/src/lib/use-linear-display.ts

@@ -0,0 +1,40 @@
+'use client'
+
+import { useViewer } from '@pascal-app/viewer'
+import { useCallback } from 'react'
+import { getLinearUnitLabel, linearUnitToMeters, metersToLinearUnit } from './measurements'
+
+/**
+ * Shared display/storage conversion for numeric property controls so that
+ * every length input honors the metric/imperial toggle identically.
+ *
+ * Values are always STORED in the field's own unit (meters for `unit === 'm'`).
+ * When the viewer preference is imperial AND the field is a meter length, the
+ * value is DISPLAYED (and edited) in feet; otherwise the conversions are the
+ * identity, so metric fields and non-length units (`'°'`, `'%'`, `'in'`, `''`,
+ * …) behave exactly as before.
+ *
+ * Used by both `SliderControl` and `MetricControl` — keep the two in sync via
+ * this single source of truth.
+ */
+export function useLinearDisplay(unit: string, precision: number) {
+  const viewerUnit = useViewer((state) => state.unit)
+  const isImperial = viewerUnit === 'imperial' && unit === 'm'
+  const displayUnit = isImperial ? getLinearUnitLabel('imperial') : unit
+
+  const toDisplay = useCallback(
+    (stored: number) => (isImperial ? metersToLinearUnit(stored, 'imperial') : stored),
+    [isImperial],
+  )
+  const toStored = useCallback(
+    (display: number) => (isImperial ? linearUnitToMeters(display, 'imperial') : display),
+    [isImperial],
+  )
+  // Round a stored value so it lands on a clean number of DISPLAY-unit digits.
+  const roundStored = useCallback(
+    (stored: number) => toStored(Number.parseFloat(toDisplay(stored).toFixed(precision))),
+    [toDisplay, toStored, precision],
+  )
+
+  return { isImperial, displayUnit, toDisplay, toStored, roundStored }
+}

package/src/lib/world-grid-snap.ts

@@ -0,0 +1,231 @@
+/**
+ * World-grid snap for tools that consume `grid:move` / `grid:click`.
+ *
+ * Tools historically snapped on `event.localPosition` (the cursor in the
+ * active building's local frame). After the floor-plan grid was pulled
+ * out of the rotated scene group, snapping has to follow the WORLD XZ
+ * grid — otherwise a rotated building drags every placement off the
+ * visible grid lines. This helper resolves the active building's pose
+ * and projects the world snap back into local coords for storage.
+ */
+import {
+  type AlignmentAnchor,
+  type AlignmentGuide,
+  type AnyNodeId,
+  type BuildingPose,
+  type ResolveAlignmentInBuildingResult,
+  resolveAlignmentInBuildingWorld,
+  snapWorldXZToBuildingLocal,
+  useLiveTransforms,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+
+/**
+ * Look up the active building's pose, or null when we're at the site root.
+ * Used by tools that need to resolve alignment in world coords.
+ *
+ * Falls back through the active level's `parentId` because the 2D floor-plan
+ * often runs with `selection.buildingId === null` while still operating
+ * inside a specific building (the user is editing a level, not the building
+ * shell itself). Without the fallback, alignment in the floor plan saw a
+ * `buildingRotY === 0` pose and emitted world-axis guides — which appeared
+ * diagonal once the building was rotated.
+ *
+ * Honours `useLiveTransforms` overrides: while the building is being moved
+ * or rotated, the floor-plan scene <g> is driven by the live transform
+ * (see `use-floorplan-scene-data.ts`), so alignment has to read the same
+ * pose or the rotated anchors fall out of sync with the SVG transform and
+ * guides drift off the visible grid mid-drag (and through any post-drag
+ * frame where the live override is still set).
+ */
+export function getActiveBuildingPose(): BuildingPose | null {
+  const sel = useViewer.getState().selection
+  const nodes = useScene.getState().nodes
+  // Match `use-floorplan-scene-data.ts`: prefer the active level's
+  // owning building, fall back to selection.buildingId. If the user
+  // has a stale building selected from another scope while editing a
+  // different level, the level path is the authoritative one.
+  let buildingId: AnyNodeId | null = null
+  if (sel.levelId) {
+    const level = nodes[sel.levelId]
+    if (level && level.type === 'level' && level.parentId) {
+      buildingId = level.parentId as AnyNodeId
+    }
+  }
+  if (!buildingId) buildingId = sel.buildingId ?? null
+  const building = buildingId ? nodes[buildingId] : null
+  if (building?.type !== 'building') return null
+  const live = useLiveTransforms.getState().transforms.get(buildingId as string)
+  return {
+    position: live?.position ?? building.position,
+    rotationY: live?.rotation ?? building.rotation[1] ?? 0,
+  }
+}
+
+/**
+ * Resolve Figma-style alignment for tools whose anchors are in the active
+ * building's local frame, but where alignment must run on the WORLD axes
+ * (the frame the user sees the grid in). Wraps `resolveAlignmentInBuildingWorld`
+ * with the active building lookup so callers don't repeat the boilerplate.
+ *
+ * Returns:
+ *   - `guides` in WORLD coords (renderer must live in a world-space group),
+ *   - `snap`   in BUILDING-LOCAL coords (ready to add to a local position).
+ */
+export function resolveAlignmentForActiveBuilding(args: {
+  moving: readonly AlignmentAnchor[]
+  candidates: readonly AlignmentAnchor[]
+  threshold: number
+}): ResolveAlignmentInBuildingResult {
+  return resolveAlignmentInBuildingWorld({ ...args, pose: getActiveBuildingPose() })
+}
+
+function worldXZToPoseLocal(x: number, z: number, pose: BuildingPose | null): [number, number] {
+  if (!pose) return [x, z]
+  const cos = Math.cos(pose.rotationY)
+  const sin = Math.sin(pose.rotationY)
+  const dx = x - pose.position[0]
+  const dz = z - pose.position[2]
+  return [dx * cos - dz * sin, dx * sin + dz * cos]
+}
+
+/**
+ * Project WORLD-frame alignment guides into the active building's LOCAL frame.
+ *
+ * The 3D alignment layer is still mounted inside the building-local tool group,
+ * so tools that resolve alignment on the world axes (item placement, slab move)
+ * need their guides converted before publishing to `useAlignmentGuides`.
+ */
+export function projectAlignmentGuidesWorldToActiveBuildingLocal(
+  guides: readonly AlignmentGuide[],
+): AlignmentGuide[] {
+  const pose = getActiveBuildingPose()
+  return guides.map((guide) => {
+    const [fromX, fromZ] = worldXZToPoseLocal(guide.from.x, guide.from.z, pose)
+    const [toX, toZ] = worldXZToPoseLocal(guide.to.x, guide.to.z, pose)
+    return {
+      ...guide,
+      from: { x: fromX, z: fromZ },
+      to: { x: toX, z: toZ },
+    }
+  })
+}
+
+/**
+ * Baseline rotation the floor-plan view applies on top of the building
+ * rotation. Mirrors `FLOORPLAN_VIEW_ROTATION_DEG = 0` in lib/floorplan/geometry.ts —
+ * the scene group reads it via `floorplanSceneRotationDeg = FVR - buildingRot`.
+ */
+const FLOORPLAN_VIEW_ROTATION_RAD = 0
+
+function rotateAnchorsBy(
+  anchors: readonly AlignmentAnchor[],
+  cos: number,
+  sin: number,
+): AlignmentAnchor[] {
+  return anchors.map((a) => ({
+    nodeId: a.nodeId,
+    kind: a.kind,
+    x: a.x * cos - a.z * sin,
+    z: a.x * sin + a.z * cos,
+  }))
+}
+
+/**
+ * Resolve alignment in the 2D floor-plan view frame — the frame the user
+ * sees the (always axis-aligned) grid lines in, regardless of how the
+ * building has been rotated. Use this from EVERY 2D floor-plan path so
+ * alignment guides stay parallel to the visible grid.
+ *
+ * Why it differs from `resolveAlignmentForActiveBuilding`: the 3D viewport
+ * shows the world XZ grid, so world-frame alignment matches the visible
+ * grid there. The 2D floor plan, however, rotates the scene `<g>` by
+ * `floorplanSceneRotationDeg = FVR − buildingRot` and renders the grid
+ * OUTSIDE that rotated group — so the visible axes are
+ * `R(FVR − buildingRot) · local`. World-frame alignment would land on
+ * world axes, which appear diagonal in this view; view-frame alignment
+ * lands on the SVG axes the user actually reads.
+ *
+ * Returns guides in view-frame coords (correct input for the floor-plan
+ * alignment-guide layer, which is mounted outside the rotated scene
+ * group) and a snap delta projected back into building-local (so callers
+ * can add it to a local position as-is).
+ */
+export function resolveAlignmentForFloorplanView(args: {
+  moving: readonly AlignmentAnchor[]
+  candidates: readonly AlignmentAnchor[]
+  threshold: number
+}): ResolveAlignmentInBuildingResult {
+  const pose = getActiveBuildingPose()
+  const buildingRotY = pose?.rotationY ?? 0
+  const rot = FLOORPLAN_VIEW_ROTATION_RAD - buildingRotY
+  const cos = Math.cos(rot)
+  const sin = Math.sin(rot)
+  const result = resolveAlignmentInBuildingWorld({
+    moving: rotateAnchorsBy(args.moving, cos, sin),
+    candidates: rotateAnchorsBy(args.candidates, cos, sin),
+    threshold: args.threshold,
+    // Pose `null` keeps `resolveAlignmentInBuildingWorld` in its no-op
+    // path: it just runs `resolveAlignment` on the already-rotated
+    // anchors and returns the snap delta in the same view frame.
+    pose: null,
+  })
+  if (!result.snap) return result
+  // View-frame delta → local-frame delta (transpose of R(rot)).
+  const { dx, dz } = result.snap
+  return {
+    guides: result.guides,
+    snap: { dx: dx * cos + dz * sin, dz: -dx * sin + dz * cos },
+  }
+}
+
+/**
+ * Snap a world XZ position to the grid, then express it in the active
+ * building's local frame. When no building is active, world == local.
+ */
+export function snapWorldXZForActiveBuilding(
+  worldX: number,
+  worldZ: number,
+  step: number,
+): { world: [number, number]; local: [number, number] } {
+  const buildingId = useViewer.getState().selection.buildingId
+  const building = buildingId ? useScene.getState().nodes[buildingId] : null
+  if (building?.type !== 'building') {
+    if (step <= 0) return { world: [worldX, worldZ], local: [worldX, worldZ] }
+    const sx = Math.round(worldX / step) * step
+    const sz = Math.round(worldZ / step) * step
+    return { world: [sx, sz], local: [sx, sz] }
+  }
+  return snapWorldXZToBuildingLocal(
+    worldX,
+    worldZ,
+    building.position,
+    building.rotation[1] ?? 0,
+    step,
+  )
+}
+
+/**
+ * Snap a building-local plan point so the resulting position sits on the
+ * world XZ grid. The returned point is still in building-local coords —
+ * useful as a `gridSnap` callback for snapWallDraftPoint / snapFenceDraftPoint
+ * etc., which operate entirely in the local frame.
+ */
+export function snapBuildingLocalToWorldGrid(
+  local: readonly [number, number],
+  step: number,
+): [number, number] {
+  const buildingId = useViewer.getState().selection.buildingId
+  const building = buildingId ? useScene.getState().nodes[buildingId] : null
+  if (building?.type !== 'building') {
+    if (step <= 0) return [local[0], local[1]]
+    return [Math.round(local[0] / step) * step, Math.round(local[1] / step) * step]
+  }
+  const rotY = building.rotation[1] ?? 0
+  const cos = Math.cos(rotY)
+  const sin = Math.sin(rotY)
+  const worldX = building.position[0] + local[0] * cos + local[1] * sin
+  const worldZ = building.position[2] - local[0] * sin + local[1] * cos
+  return snapWorldXZToBuildingLocal(worldX, worldZ, building.position, rotY, step).local
+}