@pascal-app/editor 1.0.0 → 1.0.3

package/src/lib/surface-attachment.ts

@@ -0,0 +1,77 @@
+import { type AnyNode, type AnyNodeId, useScene } from '@pascal-app/core'
+import { evaluateRecipe, isProceduralItem } from '@pascal-app/core/procedural-items'
+import { Euler, Quaternion, Vector3 } from 'three'
+
+type Pose = { position: [number, number, number]; rotation: [number, number, number] }
+
+export function surfaceAttachmentId(node: Pick<AnyNode, 'id' | 'parentId'>): string | null {
+  const parent = node.parentId ? useScene.getState().nodes[node.parentId as AnyNodeId] : undefined
+  return isProceduralItem(parent) ? (parent.attachments[node.id] ?? null) : null
+}
+
+export function surfaceAttachmentUpdates(
+  id: AnyNodeId,
+  parentId: string | null | undefined,
+  surfaceId: string | null,
+) {
+  const nodes = useScene.getState().nodes
+  const updates: { id: AnyNodeId; data: Partial<AnyNode> }[] = []
+  for (const hostId of new Set([nodes[id]?.parentId, parentId])) {
+    const host = hostId ? nodes[hostId as AnyNodeId] : undefined
+    if (!isProceduralItem(host)) continue
+    const nextId = host.id === parentId ? surfaceId : null
+    if ((host.attachments[id] ?? null) === nextId) continue
+    const attachments = { ...host.attachments }
+    if (nextId === null) delete attachments[id]
+    else attachments[id] = nextId
+    updates.push({ id: host.id, data: { attachments } })
+  }
+  return updates
+}
+
+export function updateSurfaceNode(
+  id: AnyNodeId,
+  data: Partial<AnyNode>,
+  surfaceId?: string | null,
+) {
+  const node = useScene.getState().nodes[id]
+  const parentId = data.parentId === undefined ? node?.parentId : data.parentId
+  const selected =
+    surfaceId === undefined && node && node.parentId === parentId
+      ? surfaceAttachmentId(node)
+      : (surfaceId ?? null)
+  useScene
+    .getState()
+    .updateNodes([{ id, data }, ...surfaceAttachmentUpdates(id, parentId, selected)])
+}
+
+export function surfaceFramePose(
+  parentId: string | null | undefined,
+  surfaceId: string | null,
+  pose: Pose,
+  toStorage: boolean,
+): Pose {
+  const host = parentId ? useScene.getState().nodes[parentId as AnyNodeId] : undefined
+  if (!isProceduralItem(host) || surfaceId === null)
+    return { position: pose.position, rotation: pose.rotation }
+  const surface = evaluateRecipe(host.recipe, host.parameters).surfaces.find(
+    (s) => s.id === surfaceId,
+  )
+  if (!surface) throw new Error('Missing attachment surface')
+  const q = new Quaternion().setFromEuler(new Euler(...surface.rotation))
+  const position = new Vector3(...pose.position)
+  if (toStorage) position.sub(new Vector3(...surface.position)).applyQuaternion(q.clone().invert())
+  else position.applyQuaternion(q).add(new Vector3(...surface.position))
+  if (!surface.rotation[0] && !surface.rotation[2] && !pose.rotation[0] && !pose.rotation[2]) {
+    return {
+      position: position.toArray(),
+      rotation: [0, pose.rotation[1] + (toStorage ? -1 : 1) * surface.rotation[1], 0],
+    }
+  }
+  const rotation = new Euler().setFromQuaternion(
+    new Quaternion()
+      .setFromEuler(new Euler(...pose.rotation))
+      .premultiply(toStorage ? q.invert() : q),
+  )
+  return { position: position.toArray(), rotation: [rotation.x, rotation.y, rotation.z] }
+}

package/src/lib/terrain-panel-model.ts

@@ -0,0 +1,117 @@
+'use client'
+
+import { type SiteNode, type TerrainVerb, useScene } from '@pascal-app/core'
+import useEditor from '../store/use-editor'
+import type { PanelRow } from './panel-rows'
+import { brushRadiusRange, flattenSite, resetSiteTerrain } from './terrain-sculpt'
+
+const TERRAIN_VERBS: TerrainVerb[] = ['raise', 'lower', 'flatten', 'smooth']
+
+export function useTerrainPanelRows(): PanelRow[] {
+  const verb = useEditor((state) => state.terrainVerb)
+  const setVerb = useEditor((state) => state.setTerrainVerb)
+  const brush = useEditor((state) => state.terrainBrush)
+  const setBrush = useEditor((state) => state.setTerrainBrush)
+  const flattenTarget = useEditor((state) => state.terrainFlattenTarget)
+  const setFlattenTarget = useEditor((state) => state.setTerrainFlattenTarget)
+  const sampling = useEditor((state) => state.terrainSampling)
+  const setSampling = useEditor((state) => state.setTerrainSampling)
+  const site = useScene((state) => {
+    const root = state.rootNodeIds[0]
+    const node = root ? state.nodes[root] : undefined
+    return node?.type === 'site' ? (node as SiteNode) : null
+  })
+  const [minRadius, maxRadius] = brushRadiusRange(site)
+  const verbIndex = TERRAIN_VERBS.indexOf(verb)
+  const cycleVerb = (direction: -1 | 1) => {
+    const next =
+      TERRAIN_VERBS[(verbIndex + direction + TERRAIN_VERBS.length) % TERRAIN_VERBS.length]
+    if (next) setVerb(next)
+  }
+
+  const rows: PanelRow[] = [
+    {
+      id: 'terrain-verb',
+      kind: 'cycle',
+      label: 'Brush',
+      next: () => cycleVerb(1),
+      previous: () => cycleVerb(-1),
+      value: verb.charAt(0).toUpperCase() + verb.slice(1),
+    },
+    {
+      id: 'terrain-radius',
+      kind: 'stepper',
+      label: 'Size',
+      max: maxRadius,
+      min: minRadius,
+      onChange: (radius) => setBrush({ radius }),
+      step: 0.5,
+      unit: 'm',
+      value: Math.max(minRadius, Math.min(maxRadius, brush.radius)),
+    },
+    {
+      id: 'terrain-strength',
+      kind: 'stepper',
+      label: 'Strength',
+      max: 1,
+      min: 0.05,
+      onChange: (strength) => setBrush({ strength }),
+      step: 0.05,
+      value: brush.strength,
+    },
+    {
+      id: 'terrain-softness',
+      kind: 'stepper',
+      label: 'Softness',
+      max: 1,
+      min: 0,
+      onChange: (falloff) => setBrush({ falloff }),
+      step: 0.05,
+      value: brush.falloff,
+    },
+    {
+      id: 'terrain-shape',
+      kind: 'choice',
+      label: 'Shape',
+      onSelect: () => setBrush({ shape: brush.shape === 'round' ? 'square' : 'round' }),
+      value: brush.shape === 'round' ? 'Round' : 'Square',
+    },
+    ...(verb === 'flatten'
+      ? ([
+          {
+            id: 'terrain-target',
+            kind: 'stepper',
+            label: 'Target',
+            max: 50,
+            min: -50,
+            onChange: setFlattenTarget,
+            step: 0.1,
+            unit: 'm',
+            value: flattenTarget ?? 0,
+          },
+          {
+            id: 'terrain-sampling',
+            kind: 'choice',
+            label: 'Pick height',
+            onSelect: () => setSampling(!sampling),
+            value: sampling ? 'Armed' : 'Off',
+          },
+        ] satisfies PanelRow[])
+      : []),
+    {
+      id: 'terrain-level-lot',
+      kind: 'choice',
+      label: 'Whole lot',
+      onSelect: site ? () => flattenSite(site, flattenTarget ?? 0) : undefined,
+      value: 'Level',
+    },
+    {
+      id: 'terrain-clear',
+      kind: 'choice',
+      label: 'Terrain',
+      onSelect: site?.terrain ? () => resetSiteTerrain(site) : undefined,
+      value: site?.terrain ? 'Clear' : 'Empty',
+    },
+  ]
+  return rows
+}

package/src/lib/units.ts

@@ -0,0 +1,254 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  type BuildingNode,
+  type LevelNode,
+  pointInPolygon2D,
+  resolveAutoZonePolygon,
+  snapWorldXZToBuildingLocal,
+  UnitNode,
+  useScene,
+  type ZoneNode,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { useEffect } from 'react'
+import useEditor, { type StructureLayer } from '../store/use-editor'
+import { getActiveBuildingPose } from './world-grid-snap'
+
+type Nodes = Readonly<Record<AnyNodeId, AnyNode>>
+
+// Unit focus is a session gesture: the layer the user was on when focus began
+// comes back when focus ends, unless they switched layers by hand meanwhile.
+let restoreLayer: StructureLayer | null = null
+let entering = false
+let leaving = false
+
+export function focusedUnitNode(): UnitNode | null {
+  const id = useViewer.getState().focusedUnitId
+  const node = id ? useScene.getState().nodes[id] : undefined
+  return node?.type === 'unit' ? node : null
+}
+
+/** Levels carrying member zones, lowest ordinal first. */
+export function unitMemberLevels(unit: UnitNode, nodes: Nodes): LevelNode[] {
+  const levels = new Map<LevelNode['id'], LevelNode>()
+  for (const zoneId of unit.members) {
+    const zone = nodes[zoneId]
+    const level =
+      zone?.type === 'zone' && zone.parentId ? nodes[zone.parentId as AnyNodeId] : undefined
+    if (level?.type === 'level') levels.set(level.id, level)
+  }
+  return [...levels.values()].sort((a, b) => a.level - b.level)
+}
+
+export function enterUnitFocus(unitId: UnitNode['id']): void {
+  if (entering) return
+  entering = true
+  try {
+    const nodes = useScene.getState().nodes
+    const unit = nodes[unitId]
+    if (unit?.type !== 'unit') return
+    const editor = useEditor.getState()
+    if (restoreLayer === null) restoreLayer = editor.structureLayer
+    if (editor.phase !== 'structure') editor.setPhase('structure')
+    if (useEditor.getState().structureLayer !== 'zones') {
+      useEditor.getState().setStructureLayer('zones')
+    }
+    const viewer = useViewer.getState()
+    if (viewer.focusedUnitId !== unitId) viewer.setFocusedUnit(unitId)
+
+    const { selection, setSelection } = useViewer.getState()
+    const levels = unitMemberLevels(unit, nodes)
+    const levelId = levels.some((level) => level.id === selection.levelId)
+      ? selection.levelId
+      : (levels[0]?.id ?? selection.levelId)
+    const buildingId = (unit.parentId as BuildingNode['id'] | null) ?? selection.buildingId
+    const unitSelected = selection.selectedIds.length === 1 && selection.selectedIds[0] === unitId
+    if (selection.buildingId !== buildingId || selection.levelId !== levelId || !unitSelected) {
+      setSelection({ buildingId, levelId, selectedIds: [unitId] })
+    }
+  } finally {
+    entering = false
+  }
+}
+
+function finishLeave(unitId: UnitNode['id'], keepLayer: boolean) {
+  const layer = restoreLayer
+  restoreLayer = null
+  const editor = useEditor.getState()
+  if (
+    !keepLayer &&
+    layer &&
+    layer !== 'zones' &&
+    editor.phase === 'structure' &&
+    editor.structureLayer === 'zones'
+  ) {
+    editor.setStructureLayer(layer)
+  }
+  const { selection, setSelection } = useViewer.getState()
+  if (selection.selectedIds.length === 1 && selection.selectedIds[0] === unitId) {
+    setSelection({ selectedIds: [] })
+  }
+}
+
+/** Ends unit focus. Returns false when no unit was focused. */
+export function leaveUnitFocus(options?: { keepLayer?: boolean }): boolean {
+  const viewer = useViewer.getState()
+  const unitId = viewer.focusedUnitId
+  if (!unitId) return false
+  leaving = true
+  try {
+    viewer.setFocusedUnit(null)
+  } finally {
+    leaving = false
+  }
+  finishLeave(unitId, options?.keepLayer ?? false)
+  return true
+}
+
+/**
+ * Puts a zone in exactly one unit (or none): it leaves every other unit in the
+ * same store update, so the move is one undo step.
+ */
+export function assignZoneToUnit(zoneId: ZoneNode['id'], unitId: UnitNode['id'] | null): void {
+  const { nodes, updateNodes } = useScene.getState()
+  const updates: Array<{ id: AnyNodeId; data: Partial<AnyNode> }> = []
+  for (const node of Object.values(nodes)) {
+    if (node.type !== 'unit' || node.id === unitId || !node.members.includes(zoneId)) continue
+    updates.push({ id: node.id, data: { members: node.members.filter((id) => id !== zoneId) } })
+  }
+  const target = unitId ? nodes[unitId] : undefined
+  if (target?.type === 'unit' && !target.members.includes(zoneId)) {
+    updates.push({ id: target.id, data: { members: [...target.members, zoneId] } })
+  }
+  if (updates.length > 0) updateNodes(updates)
+}
+
+export function toggleZoneMembership(unitId: UnitNode['id'], zoneId: ZoneNode['id']): void {
+  const unit = useScene.getState().nodes[unitId]
+  if (unit?.type !== 'unit') return
+  assignZoneToUnit(zoneId, unit.members.includes(zoneId) ? null : unitId)
+}
+
+/**
+ * The zone under a point on the current level, in building-local XZ. A 3D
+ * click lands on whatever surface is closest (a floor slab sits above the
+ * zone fill), so painting resolves the zone from the hit point instead of the
+ * hit mesh. Nested zones resolve to the smallest one.
+ */
+export function zoneAtLevelPoint(x: number, z: number): ZoneNode | null {
+  const levelId = useViewer.getState().selection.levelId
+  if (!levelId) return null
+  const nodes = useScene.getState().nodes
+  const resolve = (id: AnyNodeId) => nodes[id]
+  let best: ZoneNode | null = null
+  let bestArea = Number.POSITIVE_INFINITY
+  for (const node of Object.values(nodes)) {
+    if (node.type !== 'zone' || node.parentId !== levelId) continue
+    const polygon = resolveAutoZonePolygon(node, resolve)
+    if (!pointInPolygon2D([x, z], polygon)) continue
+    let area = 0
+    for (let i = 0; i < polygon.length; i++) {
+      const a = polygon[i]!
+      const b = polygon[(i + 1) % polygon.length]!
+      area += a[0] * b[1] - b[0] * a[1]
+    }
+    area = Math.abs(area) / 2
+    if (area < bestArea) {
+      best = node
+      bestArea = area
+    }
+  }
+  return best
+}
+
+export function zoneAtWorldPoint(worldX: number, worldZ: number): ZoneNode | null {
+  const pose = getActiveBuildingPose()
+  const [x, z] = pose
+    ? snapWorldXZToBuildingLocal(worldX, worldZ, pose.position, pose.rotationY, 0).local
+    : [worldX, worldZ]
+  return zoneAtLevelPoint(x, z)
+}
+
+export const ZONE_PAINT_DELAY_MS = 250
+const pendingPaints = new Map<ZoneNode['id'], ReturnType<typeof setTimeout>>()
+
+/**
+ * The canvas paint gesture. The toggle waits out the double-click window so
+ * the second click of a double-click cancels it instead of toggling twice;
+ * the double-click itself then selects the zone.
+ */
+export function paintZoneMembership(unitId: UnitNode['id'], zoneId: ZoneNode['id']): void {
+  if (cancelPendingZonePaint(zoneId)) return
+  pendingPaints.set(
+    zoneId,
+    setTimeout(() => {
+      pendingPaints.delete(zoneId)
+      toggleZoneMembership(unitId, zoneId)
+    }, ZONE_PAINT_DELAY_MS),
+  )
+}
+
+export function cancelPendingZonePaint(zoneId: ZoneNode['id']): boolean {
+  const pending = pendingPaints.get(zoneId)
+  if (!pending) return false
+  clearTimeout(pending)
+  pendingPaints.delete(zoneId)
+  return true
+}
+
+export function createUnitInBuilding(buildingId: BuildingNode['id']): UnitNode['id'] | null {
+  const scene = useScene.getState()
+  const building = scene.nodes[buildingId]
+  if (building?.type !== 'building') return null
+  const unitCount = building.children.filter((id) => scene.nodes[id]?.type === 'unit').length
+  const unit = UnitNode.parse({ name: `Unit ${unitCount + 1}` })
+  scene.createNode(unit, buildingId)
+  enterUnitFocus(unit.id)
+  return unit.id
+}
+
+/**
+ * Keeps unit focus coherent with the rest of the editor: a focus set from
+ * anywhere (the unit inspector calls the viewer store directly) gets the full
+ * enter treatment, and focus ends when the user switches layer or phase by
+ * hand, selects anything other than the focused unit, or the unit is deleted.
+ */
+export function useUnitFocusRules(): void {
+  useEffect(() => {
+    const unsubscribeViewer = useViewer.subscribe((state, prev) => {
+      if (state.focusedUnitId !== prev.focusedUnitId) {
+        if (state.focusedUnitId) enterUnitFocus(state.focusedUnitId)
+        else if (prev.focusedUnitId && !leaving) finishLeave(prev.focusedUnitId, false)
+        return
+      }
+      const unitId = state.focusedUnitId
+      if (!unitId || state.selection === prev.selection) return
+      // Selecting a zone keeps focus: renaming or recolouring a zone row is
+      // part of arranging the unit, and zones live on the layer focus uses.
+      const { selectedIds } = state.selection
+      const selectsOther =
+        selectedIds.length > 0 && !(selectedIds.length === 1 && selectedIds[0] === unitId)
+      if (selectsOther) leaveUnitFocus()
+    })
+    const unsubscribeEditor = useEditor.subscribe((state, prev) => {
+      if (state.structureLayer === prev.structureLayer && state.phase === prev.phase) return
+      if (!useViewer.getState().focusedUnitId) return
+      if (state.phase !== 'structure' || state.structureLayer !== 'zones') {
+        leaveUnitFocus({ keepLayer: true })
+      }
+    })
+    const unsubscribeScene = useScene.subscribe((state, prev) => {
+      if (state.nodes === prev.nodes) return
+      const unitId = useViewer.getState().focusedUnitId
+      if (unitId && state.nodes[unitId]?.type !== 'unit') leaveUnitFocus()
+    })
+    return () => {
+      unsubscribeViewer()
+      unsubscribeEditor()
+      unsubscribeScene()
+      for (const pending of pendingPaints.values()) clearTimeout(pending)
+      pendingPaints.clear()
+    }
+  }, [])
+}

package/src/lib/usdz-export.ts

@@ -1,13 +1,19 @@
 import type { AnyNode } from '@pascal-app/core'
 import type { Object3D } from 'three'
 import { USDZExporter } from 'three/examples/jsm/exporters/USDZExporter.js'
-import * as WebGPUTextureUtils from 'three/examples/jsm/utils/WebGPUTextureUtils.js'
-import { type GlbExportOptions, preparePortableSceneFromViewer } from './glb-export'
+import { createExportTextureUtils } from './export-texture-utils'
+import {
+  DEFAULT_MODEL_EXPORT_TIMEOUT_MS,
+  type GlbExport,
+  type GlbExportOptions,
+  preparePortableSceneFromViewer,
+  withExportDeadline,
+} from './glb-export'
 import { createUsdzScene, disposeExportResources } from './portable-export'
 
 export type UsdzExportOptions = Pick<
   GlbExportOptions,
-  'excludedNodeTypes' | 'includedPresentationIds' | 'onlyVisible' | 'onWarning'
+  'excludedNodeTypes' | 'includedPresentationIds' | 'onlyVisible' | 'onWarning' | 'timeoutMs'
 >
 
 /** Export a native, self-contained USDZ with no glTF conversion fallback. */
@@ -16,23 +22,44 @@ export async function exportSceneToUsdz(
   nodes: Record<string, AnyNode>,
   options: UsdzExportOptions = {},
 ): Promise<Uint8Array<ArrayBuffer>> {
-  const prepared = await preparePortableSceneFromViewer(sceneGroup, nodes, {
+  const textureUtils = createExportTextureUtils()
+  const preparation = preparePortableSceneFromViewer(sceneGroup, nodes, {
     ...options,
     textures: 'embed',
+    animations: 'none',
+    textureUtils,
   })
-  for (const warning of prepared.warnings) options.onWarning?.(warning)
-
-  let scene: Object3D | null = null
+  // Assigned inside the raced closure, so plain `let`s narrow to `never` in
+  // the `finally`.
+  const run: { prepared: GlbExport | null; scene: Object3D | null; abandoned: boolean } = {
+    prepared: null,
+    scene: null,
+    abandoned: false,
+  }
   try {
-    scene = createUsdzScene(prepared.scene)
-    const exporter = new USDZExporter()
-    exporter.textureUtils = WebGPUTextureUtils
-    return await exporter.parseAsync(scene, {
-      onlyVisible: options.onlyVisible ?? true,
-      quickLookCompatible: true,
-    })
+    return await withExportDeadline(
+      (async () => {
+        run.prepared = await preparation
+        if (run.abandoned) throw new Error('USDZ export abandoned')
+        for (const warning of run.prepared.warnings) options.onWarning?.(warning)
+        run.scene = createUsdzScene(run.prepared.scene)
+        const exporter = new USDZExporter()
+        exporter.textureUtils = textureUtils as unknown as USDZExporter['textureUtils']
+        return exporter.parseAsync(run.scene, {
+          onlyVisible: options.onlyVisible ?? true,
+          quickLookCompatible: true,
+        })
+      })(),
+      options.timeoutMs ?? DEFAULT_MODEL_EXPORT_TIMEOUT_MS,
+      'USDZ',
+      () => {
+        run.abandoned = true
+      },
+    )
   } finally {
-    if (scene) disposeExportResources(scene, { textures: false })
-    prepared.dispose()
+    if (run.scene) disposeExportResources(run.scene, { textures: false })
+    if (run.prepared) run.prepared.dispose()
+    else preparation.then((late) => late.dispose()).catch(() => {})
+    await textureUtils.dispose()
   }
 }

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

@@ -1,40 +1,16 @@
 'use client'
 
 import { useViewer } from '@pascal-app/viewer'
-import { useCallback } from 'react'
-import { getLinearUnitLabel, linearUnitToMeters, metersToLinearUnit } from './measurements'
+import { useMemo } from 'react'
+import { getLinearDisplay } from './linear-display'
 
-/**
- * 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) {
+/** Shared display/input conversion; values and bounds stay in the stored unit. */
+export function useLinearDisplay(unit: string, precision: number, step = 1) {
   const viewerUnit = useViewer((state) => state.unit)
-  const isImperial = viewerUnit === 'imperial' && unit === 'm'
-  const displayUnit = isImperial ? getLinearUnitLabel('imperial') : unit
+  const metricNotation = useViewer((state) => state.metricNotation)
 
-  const toDisplay = useCallback(
-    (stored: number) => (isImperial ? metersToLinearUnit(stored, 'imperial') : stored),
-    [isImperial],
+  return useMemo(
+    () => getLinearDisplay(unit, viewerUnit, metricNotation, precision, step),
+    [unit, viewerUnit, metricNotation, precision, step],
   )
-  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.test.ts

@@ -0,0 +1,48 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { BuildingNode, LevelNode, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { getActiveBuildingId } from './world-grid-snap'
+
+const originalNodes = useScene.getState().nodes
+const originalSelection = useViewer.getState().selection
+
+afterEach(() => {
+  useScene.setState({ nodes: originalNodes } as never)
+  useViewer.setState({ selection: originalSelection } as never)
+})
+
+describe('getActiveBuildingId', () => {
+  test('prefers the active level owner over a stale selected building', () => {
+    const staleBuilding = BuildingNode.parse({})
+    const activeBuilding = BuildingNode.parse({})
+    const level = LevelNode.parse({ parentId: activeBuilding.id })
+    useScene.setState({
+      nodes: {
+        [staleBuilding.id]: staleBuilding,
+        [activeBuilding.id]: activeBuilding,
+        [level.id]: level,
+      },
+    } as never)
+    useViewer.setState({
+      selection: {
+        buildingId: staleBuilding.id,
+        levelId: level.id,
+        zoneId: null,
+        selectedIds: [],
+      },
+    } as never)
+
+    expect(getActiveBuildingId()).toBe(activeBuilding.id)
+  })
+
+  test('resolves legacy level ownership from the building children list', () => {
+    const level = LevelNode.parse({})
+    const building = BuildingNode.parse({ children: [level.id] })
+    useScene.setState({ nodes: { [building.id]: building, [level.id]: level } } as never)
+    useViewer.setState({
+      selection: { buildingId: null, levelId: level.id, zoneId: null, selectedIds: [] },
+    } as never)
+
+    expect(getActiveBuildingId()).toBe(building.id)
+  })
+})

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

@@ -15,6 +15,7 @@ import {
   type BuildingPose,
   type ResolveAlignmentInBuildingResult,
   resolveAlignmentInBuildingWorld,
+  resolveBuildingForLevel,
   snapWorldXZToBuildingLocal,
   useLiveTransforms,
   useScene,
@@ -39,7 +40,7 @@ import { useViewer } from '@pascal-app/viewer'
  * 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 {
+export function getActiveBuildingId(): AnyNodeId | null {
   const sel = useViewer.getState().selection
   const nodes = useScene.getState().nodes
   // Match `use-floorplan-scene-data.ts`: prefer the active level's
@@ -48,12 +49,15 @@ export function getActiveBuildingPose(): BuildingPose | null {
   // 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
-    }
+    buildingId = resolveBuildingForLevel(sel.levelId as AnyNodeId, nodes)
   }
   if (!buildingId) buildingId = sel.buildingId ?? null
+  return buildingId
+}
+
+export function getActiveBuildingPose(): BuildingPose | null {
+  const buildingId = getActiveBuildingId()
+  const nodes = useScene.getState().nodes
   const building = buildingId ? nodes[buildingId] : null
   if (building?.type !== 'building') return null
   const live = useLiveTransforms.getState().transforms.get(buildingId as string)