@pascal-app/editor 1.0.0-beta.5 → 1.0.1

package/src/lib/editor-api.ts

@@ -1,6 +1,7 @@
-import type { AnyNode, EditorApi } from '@pascal-app/core'
+import { type AnyNode, type EditorApi, useScene } from '@pascal-app/core'
 import useEditor from '../store/use-editor'
 import useInteractionScope from '../store/use-interaction-scope'
+import { resolveDirectManipulationNode, resolveMoveActionNode } from './direct-manipulation'
 import {
   controlPointReshapeScope,
   endpointReshapeScope,
@@ -25,14 +26,16 @@ export function createEditorApi(): EditorApi {
       // (every concrete kind enumerated). Descriptors pass any node; the
       // cast lets registry-driven move kinds through without forcing a
       // schema-level type widening.
-      editor.setMovingNode(node as Parameters<typeof editor.setMovingNode>[0])
+      const target = resolveMoveActionNode(node, useScene.getState().nodes)
+      editor.setMovingNode(target as Parameters<typeof editor.setMovingNode>[0])
     },
     engageMoveDrag(node: AnyNode) {
       const editor = useEditor.getState()
       // Flag drag mode BEFORE mounting the move tool so the coordinator reads
       // it at setup and wires its commit-on-release listener.
       editor.setPlacementDragMode(true)
-      editor.setMovingNode(node as Parameters<typeof editor.setMovingNode>[0])
+      const target = resolveDirectManipulationNode(node, useScene.getState().nodes)
+      editor.setMovingNode(target as Parameters<typeof editor.setMovingNode>[0])
     },
     engageEndpointMove(node: AnyNode, endpoint: 'start' | 'end') {
       // Endpoint reshape is kind-agnostic: the scope carries the node id + which

package/src/lib/elevation-guides.test.ts

@@ -1,9 +1,10 @@
-import { describe, expect, test } from 'bun:test'
+import { afterEach, describe, expect, test } from 'bun:test'
 import { type AnyNode, CeilingNode, LevelNode, SlabNode } from '@pascal-app/core'
 import useElevationGuides from '../store/use-elevation-guides'
 import {
   clearStructuralElevationGuide,
   collectElevationSnapTargets,
+  publishResolvedElevationGuide,
   publishStructuralElevationGuide,
   resolveElevationSnapMatch,
   resolveStructuralElevationSnap,
@@ -42,6 +43,10 @@ function structuralScene() {
 }
 
 describe('elevation guides', () => {
+  afterEach(() => {
+    useElevationGuides.setState({ guide: null })
+  })
+
   test('collects the level, slab faces, and ceiling plane on the source level', () => {
     const { level, nodes, slab } = structuralScene()
     const targets = collectElevationSnapTargets(
@@ -104,4 +109,26 @@ describe('elevation guides', () => {
     publishStructuralElevationGuide(source, 0.7, nodes)
     expect(useElevationGuides.getState().guide).toBeNull()
   })
+
+  test('publishes an explicitly resolved neighboring datum', () => {
+    const { level } = structuralScene()
+    useElevationGuides.setState({ guide: null })
+
+    publishResolvedElevationGuide(
+      { nodeId: 'leanto_moving', levelId: level.id, anchor: [2, 1] },
+      {
+        id: 'leanto_neighbor:high-edge',
+        elevation: 3.4,
+        anchor: [5, 1],
+        label: 'Neighbor shed edge',
+      },
+    )
+
+    expect(useElevationGuides.getState().guide).toMatchObject({
+      ownerId: 'leanto_moving',
+      elevation: 3.4,
+      direction: [1, 0],
+      label: 'Neighbor shed edge',
+    })
+  })
 })

package/src/lib/elevation-guides.ts

@@ -1,6 +1,7 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  type FenceNode,
   findLevelAncestorId,
   getWallBaseElevationForNodes,
   getWallEffectiveHeightForNodes,
@@ -53,8 +54,10 @@ function segmentCenter(
 // A stale host resolves to the level base — the sculpted ground under the
 // fence's start point, sampled where the builder samples it, so the guide line
 // lands on the rail it claims to describe.
-function fenceBaseElevation(node: AnyNode, nodes: Record<string, AnyNode>): number {
-  if (node.type !== 'fence') return 0
+export function getFenceBaseElevationForNodes(
+  node: FenceNode,
+  nodes: Record<string, AnyNode>,
+): number {
   const host = node.supportSlabId ? nodes[node.supportSlabId as AnyNodeId] : undefined
   const hosted = host?.type === 'slab' && (host.parentId ?? null) === (node.parentId ?? null)
   const levelId = findLevelAncestorId(node.id as AnyNodeId, nodes)
@@ -161,7 +164,7 @@ export function collectElevationSnapTargets(
     }
 
     if (node.type === 'fence') {
-      const base = fenceBaseElevation(node, nodes)
+      const base = getFenceBaseElevationForNodes(node, nodes)
       const center = segmentCenter(node.start, node.end)
       targets.push({
         id: `${node.id}:base`,
@@ -245,8 +248,20 @@ export function publishStructuralElevationGuide(
     return
   }
 
-  const dx = match.target.anchor[0] - source.anchor[0]
-  const dz = match.target.anchor[1] - source.anchor[1]
+  publishResolvedElevationGuide(source, match.target)
+}
+
+export function publishResolvedElevationGuide(
+  source: ElevationGuideSource,
+  target: ElevationSnapTarget,
+): void {
+  if (!source.levelId) {
+    clearStructuralElevationGuide(source.nodeId)
+    return
+  }
+
+  const dx = target.anchor[0] - source.anchor[0]
+  const dz = target.anchor[1] - source.anchor[1]
   const length = Math.hypot(dx, dz)
   const direction: [number, number] = length > 1e-6 ? [dx / length, dz / length] : [1, 0]
 
@@ -255,8 +270,8 @@ export function publishStructuralElevationGuide(
     levelId: source.levelId,
     center: source.anchor,
     direction,
-    elevation: match.elevation,
-    label: match.target.label,
+    elevation: target.elevation,
+    label: target.label,
   })
 }
 

package/src/lib/export-texture-utils.test.ts

@@ -0,0 +1,167 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import * as THREE from 'three'
+import type { WebGPURenderer } from 'three/webgpu'
+import { createExportTextureUtils } from './export-texture-utils'
+
+const globals = globalThis as unknown as { document?: unknown }
+const previousDocument = globals.document
+
+type FakeRenderer = {
+  renderer: WebGPURenderer
+  calls: { render: number; dispose: number; destroy: number; sizes: [number, number][] }
+  domElement: object
+}
+
+function fakeRenderer(): FakeRenderer {
+  const calls = { render: 0, dispose: 0, destroy: 0, sizes: [] as [number, number][] }
+  const domElement = { kind: 'renderer-canvas' }
+  const renderer = {
+    domElement,
+    outputColorSpace: THREE.SRGBColorSpace,
+    backend: {
+      device: {
+        destroy: () => {
+          calls.destroy += 1
+        },
+      },
+    },
+    setSize: (width: number, height: number) => {
+      calls.sizes.push([width, height])
+    },
+    render: () => {
+      calls.render += 1
+    },
+    dispose: async () => {
+      calls.dispose += 1
+    },
+  }
+  return { renderer: renderer as unknown as WebGPURenderer, calls, domElement }
+}
+
+function installCanvasDocument(drawn: object[]) {
+  globals.document = {
+    createElement: (tagName: string) => {
+      if (tagName !== 'canvas') throw new Error(`Unexpected element request: ${tagName}`)
+      return {
+        width: 0,
+        height: 0,
+        getContext: () => ({
+          drawImage: (source: object) => {
+            drawn.push(source)
+          },
+        }),
+      }
+    },
+  }
+}
+
+function compressedTexture(name: string, width = 8, height = 4): THREE.CompressedTexture {
+  const texture = new THREE.CompressedTexture([], width, height)
+  texture.name = name
+  texture.colorSpace = THREE.NoColorSpace
+  texture.wrapS = THREE.RepeatWrapping
+  texture.wrapT = THREE.MirroredRepeatWrapping
+  texture.minFilter = THREE.NearestFilter
+  texture.magFilter = THREE.NearestFilter
+  return texture
+}
+
+afterEach(() => {
+  globals.document = previousDocument
+})
+
+describe('createExportTextureUtils', () => {
+  test('starts one renderer for every compressed texture in the export and releases it once', async () => {
+    const drawn: object[] = []
+    installCanvasDocument(drawn)
+    const fake = fakeRenderer()
+    let starts = 0
+    const utils = createExportTextureUtils(async () => {
+      starts += 1
+      return fake.renderer
+    })
+
+    const readable = await Promise.all([
+      utils.decompress(compressedTexture('NormalGL_a')),
+      utils.decompress(compressedTexture('Color_b', 16, 16)),
+      utils.decompress(compressedTexture('Rough_c', 2, 8)),
+    ])
+
+    expect(starts).toBe(1)
+    expect(fake.calls.render).toBe(3)
+    expect(fake.calls.sizes).toEqual([
+      [8, 4],
+      [16, 16],
+      [2, 8],
+    ])
+    expect(drawn).toEqual([fake.domElement, fake.domElement, fake.domElement])
+    expect(fake.renderer.outputColorSpace).toBe(THREE.SRGBColorSpace)
+
+    const first = readable[0] as THREE.CanvasTexture
+    expect(first.isCanvasTexture).toBe(true)
+    expect(first.name).toBe('NormalGL_a')
+    expect(first.colorSpace).toBe(THREE.NoColorSpace)
+    expect(first.wrapS).toBe(THREE.RepeatWrapping)
+    expect(first.wrapT).toBe(THREE.MirroredRepeatWrapping)
+    expect(first.minFilter).toBe(THREE.NearestFilter)
+    expect(first.magFilter).toBe(THREE.NearestFilter)
+
+    await utils.dispose()
+    await utils.dispose()
+    expect(fake.calls.dispose).toBe(1)
+    expect(fake.calls.destroy).toBe(1)
+  })
+
+  test('clamps the readback to maxTextureSize', async () => {
+    installCanvasDocument([])
+    const fake = fakeRenderer()
+    const utils = createExportTextureUtils(async () => fake.renderer)
+
+    const readable = await utils.decompress(compressedTexture('Color', 4096, 1024), 2048)
+
+    expect(fake.calls.sizes).toEqual([[2048, 1024]])
+    expect((readable.image as { width: number; height: number }).width).toBe(2048)
+    await utils.dispose()
+  })
+
+  test('rejects when no GPU renderer can start instead of leaving the export pending', async () => {
+    installCanvasDocument([])
+    const utils = createExportTextureUtils(async () => {
+      throw new Error('no adapter')
+    })
+
+    await expect(utils.decompress(compressedTexture('Color'))).rejects.toThrow('no adapter')
+    await expect(utils.decompress(compressedTexture('Color'))).rejects.toThrow('no adapter')
+    await expect(utils.dispose()).resolves.toBeUndefined()
+  })
+
+  test('disposing without decompressing never starts a renderer', async () => {
+    let starts = 0
+    const utils = createExportTextureUtils(async () => {
+      starts += 1
+      return fakeRenderer().renderer
+    })
+
+    await utils.dispose()
+    expect(starts).toBe(0)
+  })
+
+  test('a decompress after dispose rejects instead of starting an unowned renderer', async () => {
+    installCanvasDocument([])
+    const fake = fakeRenderer()
+    let starts = 0
+    const utils = createExportTextureUtils(async () => {
+      starts += 1
+      return fake.renderer
+    })
+
+    await utils.decompress(compressedTexture('Color'))
+    await utils.dispose()
+    await expect(utils.decompress(compressedTexture('Color'))).rejects.toThrow('abandoned')
+    await utils.dispose()
+
+    expect(starts).toBe(1)
+    expect(fake.calls.dispose).toBe(1)
+    expect(fake.calls.destroy).toBe(1)
+  })
+})

package/src/lib/export-texture-utils.ts

@@ -0,0 +1,121 @@
+import { initializeGpuRenderer } from '@pascal-app/viewer'
+import type * as THREE from 'three'
+import { texture as textureNode, uv } from 'three/tsl'
+import { CanvasTexture, NodeMaterial, QuadMesh, WebGPURenderer } from 'three/webgpu'
+
+/**
+ * GPU decompressor handed to three's GLTF/USDZ exporters for compressed (KTX2)
+ * textures. One instance lives for the duration of an export and is disposed
+ * with it.
+ */
+export type ExportTextureUtils = {
+  decompress(texture: THREE.Texture, maxTextureSize?: number): Promise<THREE.Texture>
+  dispose(): Promise<void>
+}
+
+// The WebGL probe context initializeGpuRenderer opens on this canvas is never
+// released, so one canvas serves every export instead of one per export.
+let probeCanvas: HTMLCanvasElement | null | undefined
+
+async function initializeDecompressRenderer(): Promise<WebGPURenderer> {
+  probeCanvas ??= typeof document === 'undefined' ? null : document.createElement('canvas')
+  const result = await initializeGpuRenderer({
+    probeCanvas,
+    createRenderer: (parameters) =>
+      new WebGPURenderer(parameters as ConstructorParameters<typeof WebGPURenderer>[0]),
+  })
+  if (result.status !== 'ready') {
+    throw new Error('Could not start a GPU renderer to decompress textures for export.', {
+      cause: result.error,
+    })
+  }
+  return result.renderer
+}
+
+function releaseDevice(renderer: WebGPURenderer) {
+  // initializeGpuRenderer hands three a caller-owned device, which
+  // WebGPUBackend.dispose() deliberately leaves alive.
+  const backend = renderer.backend as { device?: { destroy?: () => void } | null }
+  try {
+    backend.device?.destroy?.()
+  } catch {}
+}
+
+/**
+ * Mirrors three's `WebGPUTextureUtils.decompress` but keeps a single renderer
+ * for the whole export. The stock helper creates, initialises and disposes a
+ * WebGPURenderer — adapter and device request included, with no timeout — for
+ * every compressed texture it is handed, so a furnished scene paid that cost
+ * dozens of times and hung outright when one device request stalled. Handing
+ * it a renderer is not an option: it resizes whatever renderer it receives
+ * (the live viewer's canvas) and, in r186, throws on the first call that
+ * supplies one.
+ */
+export function createExportTextureUtils(
+  initialize: () => Promise<WebGPURenderer> = initializeDecompressRenderer,
+): ExportTextureUtils {
+  let pending: Promise<WebGPURenderer> | null = null
+  let disposed = false
+  const quad = new QuadMesh()
+
+  return {
+    async decompress(texture, maxTextureSize = Number.POSITIVE_INFINITY) {
+      if (disposed) {
+        throw new Error('The export was abandoned before this texture was decompressed.')
+      }
+      pending ??= initialize()
+      const renderer = await pending
+
+      // Everything below the await is synchronous, which is what lets
+      // overlapping calls share `quad` and the renderer's colour space.
+      const image = texture.image as { width: number; height: number }
+      const width = Math.min(image.width, maxTextureSize)
+      const height = Math.min(image.height, maxTextureSize)
+
+      const material = new NodeMaterial()
+      material.fragmentNode = textureNode(texture, uv().flipY())
+      const previousColorSpace = renderer.outputColorSpace
+      renderer.setSize(width, height)
+      renderer.outputColorSpace = texture.colorSpace
+      quad.material = material
+      try {
+        quad.render(renderer)
+      } finally {
+        renderer.outputColorSpace = previousColorSpace
+        material.dispose()
+      }
+
+      const canvas = document.createElement('canvas')
+      canvas.width = width
+      canvas.height = height
+      const context = canvas.getContext('2d')
+      if (!context) {
+        throw new Error('Could not create a 2D canvas to read back a decompressed texture.')
+      }
+      context.drawImage(renderer.domElement, 0, 0, width, height)
+
+      const readable = new CanvasTexture(canvas)
+      readable.minFilter = texture.minFilter
+      readable.magFilter = texture.magFilter
+      readable.wrapS = texture.wrapS
+      readable.wrapT = texture.wrapT
+      readable.colorSpace = texture.colorSpace
+      readable.name = texture.name
+      return readable
+    },
+
+    async dispose() {
+      disposed = true
+      const started = pending
+      pending = null
+      if (!started) return
+      const renderer = await started.catch(() => null)
+      if (!renderer) return
+      try {
+        await renderer.dispose()
+      } finally {
+        releaseDevice(renderer)
+      }
+    },
+  }
+}

package/src/lib/export-user-data.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from 'bun:test'
+import * as THREE from 'three'
+import { uniform } from 'three/tsl'
+import { cloneExportUserData } from './export-user-data'
+
+describe('cloneExportUserData', () => {
+  test('keeps plain data and deep-copies it', () => {
+    const source = {
+      pascalId: 'wall-1',
+      pascalSwingLeaf: { axis: 'y', openRotationY: 1.2 },
+      tags: ['a', 'b'],
+      offsets: new Float32Array([1, 2, 3]),
+    }
+    const copy = cloneExportUserData(source)
+    expect(copy).toEqual(source)
+    expect(copy.pascalSwingLeaf).not.toBe(source.pascalSwingLeaf)
+    expect(copy.tags).not.toBe(source.tags)
+    expect(copy.offsets).not.toBe(source.offsets)
+  })
+
+  test('drops functions and live three resources instead of throwing', () => {
+    const material = new THREE.MeshStandardMaterial()
+    material.addEventListener('dispose', () => {})
+    const source = {
+      pascalId: 'pool-1',
+      waterEffect: { material, uniforms: { time: uniform(0) }, strength: 0.5 },
+      mesh: new THREE.Mesh(new THREE.BoxGeometry(), material),
+      geometry: new THREE.BufferGeometry(),
+      texture: new THREE.Texture(),
+      onDispose: () => {},
+      list: [material, 'kept'],
+    }
+    expect(() => structuredClone(source)).toThrow()
+    expect(cloneExportUserData(source)).toEqual({
+      pascalId: 'pool-1',
+      waterEffect: { uniforms: {}, strength: 0.5 },
+      list: [undefined, 'kept'],
+    })
+  })
+
+  test('tolerates cycles', () => {
+    const source: Record<string, unknown> = { pascalId: 'x' }
+    source.self = source
+    const copy = cloneExportUserData(source)
+    expect(copy.pascalId).toBe('x')
+    expect(copy.self).toBe(copy)
+  })
+})

package/src/lib/export-user-data.ts

@@ -0,0 +1,69 @@
+/**
+ * Copy `userData` for an export clone. `structuredClone` throws the moment it
+ * meets a function, and live scenes keep runtime resources in userData (a
+ * plugin's effect material, TSL uniforms, a mesh reference) whose dispose
+ * listeners are functions — so a plain `structuredClone(userData)` aborts the
+ * whole export. Exports only ever read plain data back out of userData, so
+ * runtime resources and functions are dropped instead of cloned.
+ */
+
+type RuntimeResource = {
+  isObject3D?: boolean
+  isMaterial?: boolean
+  isTexture?: boolean
+  isBufferGeometry?: boolean
+  isNode?: boolean
+}
+
+function isRuntimeResource(value: object): boolean {
+  const flags = value as RuntimeResource
+  return Boolean(
+    flags.isObject3D ||
+      flags.isMaterial ||
+      flags.isTexture ||
+      flags.isBufferGeometry ||
+      flags.isNode,
+  )
+}
+
+function cloneValue(value: unknown, seen: Map<object, unknown>): unknown {
+  if (typeof value === 'function') return undefined
+  if (value === null || typeof value !== 'object') return value
+  if (seen.has(value)) return seen.get(value)
+  if (isRuntimeResource(value)) return undefined
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    const copy = structuredClone(value)
+    seen.set(value, copy)
+    return copy
+  }
+  if (value instanceof Date || value instanceof RegExp) return structuredClone(value)
+  if (Array.isArray(value)) {
+    const copy: unknown[] = []
+    seen.set(value, copy)
+    for (const entry of value) copy.push(cloneValue(entry, seen))
+    return copy
+  }
+  if (value instanceof Map) {
+    const copy = new Map<unknown, unknown>()
+    seen.set(value, copy)
+    for (const [key, entry] of value) copy.set(cloneValue(key, seen), cloneValue(entry, seen))
+    return copy
+  }
+  if (value instanceof Set) {
+    const copy = new Set<unknown>()
+    seen.set(value, copy)
+    for (const entry of value) copy.add(cloneValue(entry, seen))
+    return copy
+  }
+  const copy: Record<string, unknown> = {}
+  seen.set(value, copy)
+  for (const [key, entry] of Object.entries(value)) {
+    const cloned = cloneValue(entry, seen)
+    if (cloned !== undefined) copy[key] = cloned
+  }
+  return copy
+}
+
+export function cloneExportUserData(userData: Record<string, unknown>): Record<string, unknown> {
+  return cloneValue(userData, new Map()) as Record<string, unknown>
+}

package/src/lib/floating-menu-scale.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from 'bun:test'
+import { OrthographicCamera, PerspectiveCamera, Vector3 } from 'three'
+import { getFloatingMenuScale } from './floating-menu-scale'
+
+describe('getFloatingMenuScale', () => {
+  test('uses the standard orthographic zoom scale and clamps its range', () => {
+    const camera = new OrthographicCamera()
+    const anchor = new Vector3()
+
+    camera.zoom = 15
+    expect(getFloatingMenuScale(camera, anchor)).toBe(0.75)
+    camera.zoom = 2
+    expect(getFloatingMenuScale(camera, anchor)).toBe(0.5)
+    camera.zoom = 40
+    expect(getFloatingMenuScale(camera, anchor)).toBe(1)
+  })
+
+  test('uses inverse perspective-camera distance and clamps its range', () => {
+    const camera = new PerspectiveCamera()
+    const anchor = new Vector3()
+
+    camera.position.set(0, 0, 16)
+    expect(getFloatingMenuScale(camera, anchor)).toBe(0.75)
+    camera.position.set(0, 0, 48)
+    expect(getFloatingMenuScale(camera, anchor)).toBe(0.5)
+    camera.position.set(0, 0, 6)
+    expect(getFloatingMenuScale(camera, anchor)).toBe(1)
+  })
+})

package/src/lib/floating-menu-scale.ts

@@ -0,0 +1,14 @@
+import { type Camera, OrthographicCamera, type Vector3 } from 'three'
+
+const MIN_MENU_SCALE = 0.5
+const MAX_MENU_SCALE = 1
+const REF_ORTHO_ZOOM = 20
+const REF_CAMERA_DISTANCE = 12
+
+export function getFloatingMenuScale(camera: Camera, anchor: Vector3): number {
+  const raw =
+    camera instanceof OrthographicCamera
+      ? camera.zoom / REF_ORTHO_ZOOM
+      : REF_CAMERA_DISTANCE / Math.max(camera.position.distanceTo(anchor), 0.001)
+  return Math.min(MAX_MENU_SCALE, Math.max(MIN_MENU_SCALE, raw))
+}

package/src/lib/floorplan/apply-alignment.test.ts

@@ -1,8 +1,23 @@
-import { afterEach, describe, expect, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { LevelNode, useScene, WallNode } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
 import useAlignmentGuides from '../../store/use-alignment-guides'
-import { applyFloorplanAlignment } from './apply-alignment'
+import { alignFloorplanDraftPoint, applyFloorplanAlignment } from './apply-alignment'
 
 describe('applyFloorplanAlignment', () => {
+  beforeEach(() => {
+    // These tests assume no active building (alignment runs on world axes).
+    // The scene/viewer stores are process-wide singletons, so an earlier test
+    // FILE can leak a selected building fixture into them — under bun's
+    // platform-dependent file order that turned into an order-dependent
+    // failure (getActiveBuildingPose reading a fixture building without a
+    // rotation array). Pin the empty-scene context explicitly.
+    useScene.setState({ nodes: {} } as never)
+    useViewer.setState({
+      selection: { buildingId: null, levelId: null, zoneId: null, selectedIds: [] },
+    } as never)
+  })
+
   afterEach(() => {
     useAlignmentGuides.getState().clear()
   })
@@ -22,4 +37,34 @@ describe('applyFloorplanAlignment', () => {
     expect(result.guides).toHaveLength(1)
     expect(useAlignmentGuides.getState().guides).toHaveLength(1)
   })
+
+  test('can restrict candidates to the active level', () => {
+    const lowerLevel = LevelNode.parse({ id: 'level_lower', level: 0 })
+    const upperLevel = LevelNode.parse({ id: 'level_upper', level: 1 })
+    const lowerWall = WallNode.parse({
+      id: 'wall_lower',
+      parentId: lowerLevel.id,
+      start: [10, 10],
+      end: [14, 10],
+    })
+    const upperWall = WallNode.parse({
+      id: 'wall_upper',
+      parentId: upperLevel.id,
+      start: [0, 0],
+      end: [4, 0],
+    })
+    useScene.setState({
+      nodes: Object.fromEntries(
+        [lowerLevel, upperLevel, lowerWall, upperWall].map((node) => [node.id, node]),
+      ),
+    } as never)
+
+    expect(
+      alignFloorplanDraftPoint([0.04, 0], {
+        applySnap: true,
+        levelId: lowerLevel.id,
+      }),
+    ).toEqual([0.04, 0])
+    expect(useAlignmentGuides.getState().guides).toHaveLength(0)
+  })
 })

package/src/lib/floorplan/apply-alignment.ts

@@ -2,6 +2,7 @@ import {
   type AlignmentAnchor,
   type AlignmentGuide,
   collectAlignmentAnchors,
+  resolveLevelId,
   useScene,
 } from '@pascal-app/core'
 import useAlignmentGuides from '../../store/use-alignment-guides'
@@ -96,13 +97,21 @@ export function alignFloorplanDraftPoint(
     bypass?: boolean
     threshold?: number
     excludeIds?: readonly string[]
+    levelId?: string | null
   },
 ): [number, number] {
   if (opts?.bypass) {
     useAlignmentGuides.getState().clear()
     return [point[0], point[1]]
   }
-  let candidates = collectAlignmentAnchors(useScene.getState().nodes, FLOORPLAN_DRAFT_ALIGN_ID)
+  const nodes = useScene.getState().nodes
+  let candidates = collectAlignmentAnchors(nodes, FLOORPLAN_DRAFT_ALIGN_ID)
+  if (opts && 'levelId' in opts) {
+    candidates = candidates.filter((anchor) => {
+      const candidate = nodes[anchor.nodeId as keyof typeof nodes]
+      return candidate ? resolveLevelId(candidate, nodes) === opts.levelId : false
+    })
+  }
   if (opts?.excludeIds?.length) {
     const excluded = new Set(opts.excludeIds)
     candidates = candidates.filter((anchor) => !excluded.has(anchor.nodeId))