@pascal-app/editor 0.8.0 → 0.9.1

package/src/lib/stair-levels.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  BuildingNode,
+  LevelNode,
+  StairNode,
+} from '@pascal-app/core/schema'
+import {
+  getBuildingLevelsForLevel,
+  getStairLevelOptions,
+  resolveStairDestinationLevel,
+  resolveStairFromLevelId,
+  resolveStairPlacementLevelId,
+  resolveStairToLevelId,
+} from './stair-levels'
+
+describe('stair level helpers', () => {
+  test('creates a missing upper level in the same building', () => {
+    const ground = LevelNode.parse({ level: 0, children: [] })
+    const building = BuildingNode.parse({ children: [ground.id] })
+    const nodes = {
+      [building.id]: building,
+      [ground.id]: ground,
+    } as Record<AnyNodeId, AnyNode>
+
+    const plan = resolveStairDestinationLevel({
+      createMissing: true,
+      fromLevelId: ground.id,
+      nodes,
+    })
+
+    expect(plan?.buildingId).toBe(building.id)
+    expect(plan?.fromLevel.id).toBe(ground.id)
+    expect(plan?.toLevel.level).toBe(1)
+    expect(plan?.toLevel.id).toBe(plan?.createdLevel?.id)
+    expect(plan?.createdLevel?.parentId).toBe(building.id)
+  })
+
+  test('uses the nearest higher sibling level instead of creating one', () => {
+    const building = BuildingNode.parse({})
+    const ground = LevelNode.parse({ level: 0, parentId: building.id })
+    const second = LevelNode.parse({ level: 1, parentId: building.id })
+    const third = LevelNode.parse({ level: 2, parentId: building.id })
+    const nodes = {
+      [building.id]: { ...building, children: [ground.id, third.id, second.id] },
+      [ground.id]: ground,
+      [second.id]: second,
+      [third.id]: third,
+    } as Record<AnyNodeId, AnyNode>
+
+    const plan = resolveStairDestinationLevel({
+      createMissing: true,
+      fromLevelId: ground.id,
+      nodes,
+    })
+
+    expect(plan?.createdLevel).toBeNull()
+    expect(plan?.toLevel.id).toBe(second.id)
+  })
+
+  test('ignores levels from other buildings', () => {
+    const buildingA = BuildingNode.parse({})
+    const buildingB = BuildingNode.parse({})
+    const groundA = LevelNode.parse({ level: 0, parentId: buildingA.id })
+    const upperA = LevelNode.parse({ level: 1, parentId: buildingA.id })
+    const upperB = LevelNode.parse({ level: 1, parentId: buildingB.id })
+    const nodes = {
+      [buildingA.id]: { ...buildingA, children: [groundA.id, upperA.id] },
+      [buildingB.id]: { ...buildingB, children: [upperB.id] },
+      [groundA.id]: groundA,
+      [upperA.id]: upperA,
+      [upperB.id]: upperB,
+    } as Record<AnyNodeId, AnyNode>
+
+    expect(getBuildingLevelsForLevel(nodes, groundA.id).map((level) => level.id)).toEqual([
+      groundA.id,
+      upperA.id,
+    ])
+    expect(
+      resolveStairDestinationLevel({ createMissing: true, fromLevelId: groundA.id, nodes })?.toLevel
+        .id,
+    ).toBe(upperA.id)
+  })
+
+  test('includes source and parent-linked sibling levels when building children are stale', () => {
+    const building = BuildingNode.parse({ children: [] })
+    const ground = LevelNode.parse({ level: 0, parentId: building.id })
+    const upper = LevelNode.parse({ level: 1, parentId: building.id })
+    const nodes = {
+      [building.id]: building,
+      [ground.id]: ground,
+      [upper.id]: upper,
+    } as Record<AnyNodeId, AnyNode>
+
+    const levels = getBuildingLevelsForLevel(nodes, ground.id)
+    const plan = resolveStairDestinationLevel({
+      createMissing: true,
+      fromLevelId: ground.id,
+      nodes,
+    })
+
+    expect(levels.map((level) => level.id)).toEqual([ground.id, upper.id])
+    expect(plan?.createdLevel).toBeNull()
+    expect(plan?.toLevel.id).toBe(upper.id)
+  })
+
+  test('falls back from stale placement level ids to a valid level in the selected building', () => {
+    const buildingA = BuildingNode.parse({})
+    const groundA = LevelNode.parse({ level: 0, parentId: buildingA.id })
+    const buildingB = BuildingNode.parse({})
+    const groundB = LevelNode.parse({ level: 0, parentId: buildingB.id })
+    const nodes = {
+      [buildingA.id]: { ...buildingA, children: [groundA.id] },
+      [groundA.id]: groundA,
+      [buildingB.id]: { ...buildingB, children: [groundB.id] },
+      [groundB.id]: groundB,
+    } as Record<AnyNodeId, AnyNode>
+
+    expect(resolveStairPlacementLevelId(nodes, 'level_missing', buildingB.id)).toBe(groundB.id)
+  })
+
+  test('repairs panel level ids for stairs with stale from-level data', () => {
+    const building = BuildingNode.parse({})
+    const ground = LevelNode.parse({ level: 0, parentId: building.id })
+    const upper = LevelNode.parse({ level: 1, parentId: building.id })
+    const stair = StairNode.parse({
+      parentId: ground.id,
+      fromLevelId: 'default',
+      toLevelId: upper.id,
+    })
+    const nodes = {
+      [building.id]: { ...building, children: [ground.id, upper.id] },
+      [ground.id]: ground,
+      [upper.id]: upper,
+      [stair.id]: stair,
+    } as Record<AnyNodeId, AnyNode>
+
+    const levels = getStairLevelOptions(nodes, stair)
+    const fromLevelId = resolveStairFromLevelId(nodes, stair, levels)
+
+    expect(levels.map((level) => level.id)).toEqual([ground.id, upper.id])
+    expect(fromLevelId).toBe(ground.id)
+    expect(resolveStairToLevelId(nodes, stair, fromLevelId, levels)).toBe(upper.id)
+  })
+})

package/src/lib/stair-levels.ts

@@ -0,0 +1,177 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  LevelNode,
+  type LevelNode as LevelNodeType,
+  resolveBuildingForLevel,
+  type StairNode,
+} from '@pascal-app/core'
+
+function sortLevelsByHeight(levels: LevelNodeType[]) {
+  return [...levels].sort((left, right) => left.level - right.level)
+}
+
+function isLevelNode(node: AnyNode | undefined): node is LevelNodeType {
+  return node?.type === 'level'
+}
+
+function getAllSceneLevels(nodes: Record<string, AnyNode>) {
+  return sortLevelsByHeight(
+    Object.values(nodes).filter((entry): entry is LevelNodeType => entry?.type === 'level'),
+  )
+}
+
+function getBuildingLevels(
+  nodes: Record<string, AnyNode>,
+  buildingId: AnyNodeId | string | null | undefined,
+  source?: LevelNodeType,
+) {
+  if (!buildingId) return source ? [source] : []
+  const building = nodes[buildingId as AnyNodeId]
+  if (building?.type !== 'building') return source ? [source] : []
+
+  const levels = new Map<string, LevelNodeType>()
+  if (source) levels.set(source.id, source)
+
+  for (const childId of building.children ?? []) {
+    const child = nodes[childId as AnyNodeId]
+    if (isLevelNode(child)) levels.set(child.id, child)
+  }
+
+  for (const candidate of Object.values(nodes)) {
+    if (isLevelNode(candidate) && candidate.parentId === building.id) {
+      levels.set(candidate.id, candidate)
+    }
+  }
+
+  return sortLevelsByHeight(Array.from(levels.values()))
+}
+
+export function getBuildingLevelsForLevel(
+  nodes: Record<string, AnyNode>,
+  levelId: AnyNodeId | string | null | undefined,
+) {
+  if (!levelId) return []
+  const source = nodes[levelId as AnyNodeId]
+  if (!isLevelNode(source)) return []
+
+  const buildingId = resolveBuildingForLevel(
+    source.id as AnyNodeId,
+    nodes as Record<AnyNodeId, AnyNode>,
+  )
+  return getBuildingLevels(nodes, buildingId, source)
+}
+
+export function getStairLevelOptions(nodes: Record<string, AnyNode>, stair: StairNode) {
+  for (const candidateId of [stair.fromLevelId, stair.parentId, stair.toLevelId]) {
+    if (isLevelNode(nodes[candidateId as AnyNodeId])) {
+      return getBuildingLevelsForLevel(nodes, candidateId)
+    }
+  }
+
+  return getAllSceneLevels(nodes)
+}
+
+export function resolveStairPlacementLevelId(
+  nodes: Record<string, AnyNode>,
+  preferredLevelId: AnyNodeId | string | null | undefined,
+  preferredBuildingId?: AnyNodeId | string | null,
+) {
+  if (isLevelNode(nodes[preferredLevelId as AnyNodeId])) {
+    return preferredLevelId as LevelNodeType['id']
+  }
+
+  const buildingLevels = getBuildingLevels(nodes, preferredBuildingId)
+  return buildingLevels[0]?.id ?? getAllSceneLevels(nodes)[0]?.id ?? null
+}
+
+export function resolveStairFromLevelId(
+  nodes: Record<string, AnyNode>,
+  stair: StairNode,
+  levels = getStairLevelOptions(nodes, stair),
+) {
+  const optionIds = new Set<string>(levels.map((level) => level.id))
+  if (stair.fromLevelId && optionIds.has(stair.fromLevelId)) return stair.fromLevelId
+  if (stair.parentId && optionIds.has(stair.parentId)) return stair.parentId
+
+  const toLevel = stair.toLevelId ? nodes[stair.toLevelId as AnyNodeId] : undefined
+  if (isLevelNode(toLevel)) {
+    const lowerLevel = [...levels].reverse().find((level) => level.level < toLevel.level)
+    if (lowerLevel) return lowerLevel.id
+  }
+
+  return levels[0]?.id ?? null
+}
+
+export function resolveStairToLevelId(
+  nodes: Record<string, AnyNode>,
+  stair: StairNode,
+  fromLevelId: AnyNodeId | string | null | undefined,
+  levels = getStairLevelOptions(nodes, stair),
+) {
+  const optionIds = new Set<string>(levels.map((level) => level.id))
+  if (stair.toLevelId && stair.toLevelId !== fromLevelId && optionIds.has(stair.toLevelId)) {
+    return stair.toLevelId
+  }
+
+  const fromLevel = fromLevelId ? nodes[fromLevelId as AnyNodeId] : undefined
+  if (isLevelNode(fromLevel)) {
+    return levels.find((level) => level.level > fromLevel.level)?.id ?? fromLevel.id
+  }
+
+  return levels[0]?.id ?? null
+}
+
+export function resolveStairDestinationLevel({
+  createMissing,
+  fromLevelId,
+  nodes,
+}: {
+  createMissing?: boolean
+  fromLevelId: AnyNodeId | string | null | undefined
+  nodes: Record<string, AnyNode>
+}) {
+  if (!fromLevelId) return null
+  const fromLevel = nodes[fromLevelId as AnyNodeId]
+  if (!isLevelNode(fromLevel)) return null
+
+  const buildingId = resolveBuildingForLevel(
+    fromLevel.id as AnyNodeId,
+    nodes as Record<AnyNodeId, AnyNode>,
+  )
+  const levels = getBuildingLevelsForLevel(nodes, fromLevel.id)
+  const nextExistingLevel = levels.find((level) => level.level > fromLevel.level) ?? null
+  if (nextExistingLevel) {
+    return {
+      buildingId,
+      createdLevel: null,
+      fromLevel,
+      levels,
+      toLevel: nextExistingLevel,
+    }
+  }
+
+  if (createMissing && buildingId) {
+    const createdLevel = LevelNode.parse({
+      children: [],
+      level: fromLevel.level + 1,
+      parentId: buildingId,
+    })
+
+    return {
+      buildingId,
+      createdLevel,
+      fromLevel,
+      levels: sortLevelsByHeight([...levels, createdLevel]),
+      toLevel: createdLevel,
+    }
+  }
+
+  return {
+    buildingId,
+    createdLevel: null,
+    fromLevel,
+    levels,
+    toLevel: fromLevel,
+  }
+}

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

@@ -0,0 +1,199 @@
+/**
+ * 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 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 || 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() })
+}
+
+/**
+ * Baseline rotation the floor-plan view applies on top of the building
+ * rotation. Mirrors `FLOORPLAN_VIEW_ROTATION_DEG = 90` in floorplan-panel.tsx —
+ * the scene group reads it via `floorplanSceneRotationDeg = FVR - buildingRot`.
+ */
+const FLOORPLAN_VIEW_ROTATION_RAD = Math.PI / 2
+
+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 || 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 || 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
+}

package/src/lib/zone-content.ts

@@ -0,0 +1,130 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  type CeilingNode,
+  type ItemNode,
+  pointInPolygon2D,
+  pointOnSegment,
+  type SlabNode,
+  type WallNode,
+  type ZoneNode,
+} from '@pascal-app/core'
+
+type Point2D = [number, number]
+
+const POINT_TOLERANCE = 0.5
+const COLLINEAR_TOLERANCE = 1e-6
+const SURFACE_POLYGON_TOLERANCE = 0.15
+
+function getPointToSegmentDistance(point: Point2D, start: Point2D, end: Point2D): number {
+  const dx = end[0] - start[0]
+  const dz = end[1] - start[1]
+  const lengthSq = dx * dx + dz * dz
+  if (lengthSq === 0) return Math.hypot(point[0] - start[0], point[1] - start[1])
+
+  const rawT = ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / lengthSq
+  const t = Math.max(0, Math.min(1, rawT))
+  const projected: Point2D = [start[0] + t * dx, start[1] + t * dz]
+  return Math.hypot(point[0] - projected[0], point[1] - projected[1])
+}
+
+function pointInPolygonWithTolerance(point: Point2D, polygon: Point2D[]): boolean {
+  if (pointInPolygon2D(point, polygon, { includeBoundary: true })) return true
+  return polygon.some((start, index) => {
+    const end = polygon[(index + 1) % polygon.length]
+    return end ? getPointToSegmentDistance(point, start, end) <= POINT_TOLERANCE : false
+  })
+}
+
+function polygonContainsWithTolerance(
+  outer: Point2D[],
+  inner: Point2D[],
+  tolerance: number,
+): boolean {
+  return inner.every((point) => {
+    if (pointInPolygon2D(point, outer, { includeBoundary: true })) return true
+    return outer.some((start, index) => {
+      const end = outer[(index + 1) % outer.length]
+      return end ? getPointToSegmentDistance(point, start, end) <= tolerance : false
+    })
+  })
+}
+
+function polygonMatchesZoneFootprint(surfacePolygon: Point2D[], footprint: Point2D[]): boolean {
+  if (surfacePolygon.length < 3) return false
+  return (
+    polygonContainsWithTolerance(footprint, surfacePolygon, SURFACE_POLYGON_TOLERANCE) &&
+    polygonContainsWithTolerance(surfacePolygon, footprint, SURFACE_POLYGON_TOLERANCE)
+  )
+}
+
+function areSegmentsCollinear(a: Point2D, b: Point2D, c: Point2D, d: Point2D): boolean {
+  const abx = b[0] - a[0]
+  const abz = b[1] - a[1]
+  const acx = c[0] - a[0]
+  const acz = c[1] - a[1]
+  const adx = d[0] - a[0]
+  const adz = d[1] - a[1]
+  const crossC = abx * acz - abz * acx
+  const crossD = abx * adz - abz * adx
+  return Math.abs(crossC) <= COLLINEAR_TOLERANCE && Math.abs(crossD) <= COLLINEAR_TOLERANCE
+}
+
+function segmentsOverlap(a: Point2D, b: Point2D, c: Point2D, d: Point2D): boolean {
+  const useX = Math.abs(b[0] - a[0]) >= Math.abs(b[1] - a[1])
+  const a0 = useX ? a[0] : a[1]
+  const a1 = useX ? b[0] : b[1]
+  const c0 = useX ? c[0] : c[1]
+  const c1 = useX ? d[0] : d[1]
+  const minA = Math.min(a0, a1)
+  const maxA = Math.max(a0, a1)
+  const minC = Math.min(c0, c1)
+  const maxC = Math.max(c0, c1)
+  return Math.max(minA, minC) <= Math.min(maxA, maxC) + COLLINEAR_TOLERANCE
+}
+
+function wallLiesOnZoneBoundary(wall: WallNode, polygon: Point2D[]): boolean {
+  return polygon.some((start, index) => {
+    const end = polygon[(index + 1) % polygon.length]
+    if (!end) return false
+    return (
+      areSegmentsCollinear(wall.start, wall.end, start, end) &&
+      segmentsOverlap(wall.start, wall.end, start, end) &&
+      pointOnSegment(wall.start, start, end, POINT_TOLERANCE) &&
+      pointOnSegment(wall.end, start, end, POINT_TOLERANCE)
+    )
+  })
+}
+
+export function collectZoneContentIds(
+  nodes: Readonly<Record<AnyNodeId, AnyNode>>,
+  zone: ZoneNode,
+): AnyNodeId[] {
+  const levelId = zone.parentId
+  if (!levelId) return []
+
+  const footprint = zone.polygon.map((point) => [point[0], point[1]] as Point2D)
+  const boundaryWalls = Object.values(nodes)
+    .filter((node): node is WallNode => node.type === 'wall' && node.parentId === levelId)
+    .filter((wall) => wallLiesOnZoneBoundary(wall, footprint))
+  const surfaces = Object.values(nodes)
+    .filter(
+      (node): node is SlabNode | CeilingNode =>
+        (node.type === 'slab' || node.type === 'ceiling') && node.parentId === levelId,
+    )
+    .filter((surface) => {
+      const polygon = surface.polygon.map((point) => [point[0], point[1]] as Point2D)
+      return polygonMatchesZoneFootprint(polygon, footprint)
+    })
+  const floorItems = Object.values(nodes)
+    .filter((node): node is ItemNode => node.type === 'item' && node.parentId === levelId)
+    .filter((item) => pointInPolygonWithTolerance([item.position[0], item.position[2]], footprint))
+
+  return Array.from(
+    new Set<AnyNodeId>([
+      ...boundaryWalls.map((wall) => wall.id as AnyNodeId),
+      ...surfaces.map((surface) => surface.id as AnyNodeId),
+      ...floorItems.map((item) => item.id as AnyNodeId),
+    ]),
+  )
+}

package/src/store/use-alignment-guides.ts

@@ -0,0 +1,21 @@
+// Ephemeral store for Figma-style alignment guides published during a
+// move / placement drag. The producer (a tool or move overlay) writes
+// guides on pointermove; the renderer (a 2D / 3D guide layer) subscribes
+// and draws them. Both sides clear on commit, cancel, and unmount.
+
+import type { AlignmentGuide } from '@pascal-app/core'
+import { create } from 'zustand'
+
+type AlignmentGuidesState = {
+  guides: AlignmentGuide[]
+  set(guides: AlignmentGuide[]): void
+  clear(): void
+}
+
+const useAlignmentGuides = create<AlignmentGuidesState>((set) => ({
+  guides: [],
+  set: (guides) => set({ guides }),
+  clear: () => set({ guides: [] }),
+}))
+
+export default useAlignmentGuides