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

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/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))

package/src/lib/floorplan/floorplan-export.test.ts

@@ -1,11 +1,24 @@
 import { describe, expect, test } from 'bun:test'
-import type { FloorplanGeometry } from '@pascal-app/core'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  type FloorplanGeometry,
+  type GeometryContext,
+  loadPlugin,
+  type NodeCategory,
+  nodeRegistry,
+  registerNode,
+} from '@pascal-app/core'
+import PDFDocument from 'pdfkit'
+import { z } from 'zod'
 import { splitFloorplanOverlay } from '../../components/editor-2d/renderers/floorplan-registry-layer'
 import { DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY } from './annotation-visibility'
 import {
+  collectFloorplanGeometry,
   filterFloorplanExportOverlay,
   fitPlanToBox,
   isFloorplanExportAnnotationGeometry,
+  isFloorplanNodeInExportScope,
   partitionFloorplanExportOverlay,
   resolveFloorplanExportAnnotationVisibility,
   resolveFloorplanExportNodeGeometry,
@@ -19,6 +32,63 @@ import {
   rotateFloorplanExportBounds,
 } from './floorplan-export'
 import { floorplanGeometryMetadata } from './floorplan-extension'
+import { FloorplanPdfDocument } from './floorplan-pdfkit-document'
+import { renderFloorplanGeometryToPdfKit } from './floorplan-pdfkit-renderer'
+
+type GroupGeometry = Extract<FloorplanGeometry, { kind: 'group' }>
+type GroupTransform = NonNullable<GroupGeometry['transform']>
+
+function flattenGeometry(geometry: FloorplanGeometry | null): FloorplanGeometry[] {
+  if (!geometry) return []
+  if (geometry.kind !== 'group') return [geometry]
+  return [geometry, ...geometry.children.flatMap(flattenGeometry)]
+}
+
+function applyGeometryTransforms(
+  point: readonly [number, number],
+  transforms: readonly GroupTransform[],
+): [number, number] {
+  let x = point[0]
+  let y = point[1]
+  for (let index = transforms.length - 1; index >= 0; index -= 1) {
+    const transform = transforms[index]!
+    if (transform.rotate !== undefined) {
+      const cos = Math.cos(transform.rotate)
+      const sin = Math.sin(transform.rotate)
+      const rotatedX = x * cos - y * sin
+      y = x * sin + y * cos
+      x = rotatedX
+    }
+    if (transform.translate) {
+      x += transform.translate[0]
+      y += transform.translate[1]
+    }
+  }
+  return [x, y]
+}
+
+function projectedGeometryPoint(
+  geometry: FloorplanGeometry,
+  target: 'circle' | 'image',
+  transforms: readonly GroupTransform[] = [],
+): [number, number] | null {
+  if (geometry.kind === target) {
+    const point =
+      geometry.kind === 'circle'
+        ? ([geometry.cx, geometry.cy] as const)
+        : geometry.kind === 'image'
+          ? geometry.center
+          : null
+    return point ? applyGeometryTransforms(point, transforms) : null
+  }
+  if (geometry.kind !== 'group') return null
+  const nestedTransforms = geometry.transform ? [...transforms, geometry.transform] : transforms
+  for (const child of geometry.children) {
+    const point = projectedGeometryPoint(child, target, nestedTransforms)
+    if (point) return point
+  }
+  return null
+}
 
 describe('filterFloorplanExportOverlay', () => {
   test('preserves annotation metadata while splitting geometry passes', () => {
@@ -317,3 +387,329 @@ describe('resolveFloorplanPageLayout', () => {
     })
   })
 })
+
+describe('isFloorplanNodeInExportScope', () => {
+  const definition = (category?: NodeCategory) => ({ category })
+
+  test('includes structure-category nodes under structure and full', () => {
+    expect(isFloorplanNodeInExportScope(definition('structure'), 'structure')).toBe(true)
+    expect(isFloorplanNodeInExportScope(definition('structure'), 'full')).toBe(true)
+  })
+
+  test('excludes utility-category nodes under structure', () => {
+    expect(isFloorplanNodeInExportScope(definition('utility'), 'full')).toBe(true)
+    expect(isFloorplanNodeInExportScope(definition('utility'), 'structure')).toBe(false)
+  })
+
+  test('includes furnish-category nodes only under full', () => {
+    expect(isFloorplanNodeInExportScope(definition('furnish'), 'full')).toBe(true)
+    expect(isFloorplanNodeInExportScope(definition('furnish'), 'structure')).toBe(false)
+  })
+
+  test('includes analysis and site-category nodes only under full', () => {
+    for (const category of ['analysis', 'site'] as const) {
+      expect(isFloorplanNodeInExportScope(definition(category), 'full')).toBe(true)
+      expect(isFloorplanNodeInExportScope(definition(category), 'structure')).toBe(false)
+    }
+  })
+
+  test('excludes nodes with no category except under full', () => {
+    expect(isFloorplanNodeInExportScope(definition(undefined), 'full')).toBe(true)
+    expect(isFloorplanNodeInExportScope(definition(undefined), 'structure')).toBe(false)
+  })
+
+  test('handles an undefined definition like a no-category node', () => {
+    expect(isFloorplanNodeInExportScope(undefined, 'full')).toBe(true)
+    expect(isFloorplanNodeInExportScope(undefined, 'structure')).toBe(false)
+  })
+})
+
+describe('collectFloorplanGeometry', () => {
+  test('collects the active Site once below architecture with semantic context and projection', async () => {
+    const restoreRegistry = nodeRegistry._snapshot()
+    const activeSiteId = 'site_active'
+    const otherSiteId = 'site_other'
+    const enabledPluginId = 'test:site-pdf-enabled'
+    const disabledPluginId = 'test:site-pdf-disabled'
+    const enabledKind = 'test:site-pdf-overlay'
+    const disabledKind = 'test:site-pdf-disabled-overlay'
+    const architectureKind = 'test:level-architecture'
+    const semanticChildId = 'site_overlay_detail'
+    const referencedNodeId = 'site_reference'
+    const inlinePng =
+      'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII='
+
+    const siteDefinition = (
+      kind: string,
+      floorplan: (node: Record<string, unknown>, context: GeometryContext) => FloorplanGeometry,
+    ): AnyNodeDefinition =>
+      ({
+        kind,
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal(kind) }) as never,
+        category: 'utility',
+        defaults: () => ({}) as never,
+        capabilities: {},
+        floorplanScope: 'site',
+        floorplan,
+      }) as AnyNodeDefinition
+
+    const enabledDefinition = siteDefinition(enabledKind, (siteOverlay, context) => ({
+      kind: 'group',
+      children: [
+        {
+          kind: 'rect',
+          x: 10,
+          y: 3,
+          width: context.children[0]?.id === semanticChildId ? 3 : -3,
+          height: context.siblings.some(({ id }) => id === 'site_overlay_hidden') ? 4 : -4,
+          fill:
+            siteOverlay.id === 'site_overlay' &&
+            context.parent?.id === activeSiteId &&
+            context.resolve(referencedNodeId)?.id === referencedNodeId
+              ? '#102030'
+              : '#ff0000',
+        },
+        {
+          kind: 'path',
+          d: 'M0,0H4V4H0ZM1,1H3V3H1Z',
+          fill: '#3f6b2f',
+          fillRule: 'evenodd',
+        },
+        {
+          kind: 'image',
+          url: inlinePng,
+          center: [10, 3],
+          width: 1,
+          height: 1,
+        },
+        { kind: 'circle', cx: 12, cy: 5, r: 0.5 },
+      ],
+    }))
+
+    try {
+      nodeRegistry._reset()
+      registerNode({
+        kind: architectureKind,
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal(architectureKind) }) as never,
+        category: 'structure',
+        defaults: () => ({}) as never,
+        capabilities: {},
+        floorplan: () => ({
+          kind: 'polygon',
+          points: [
+            [0, 0],
+            [4, 0],
+            [4, 4],
+          ],
+        }),
+      } as AnyNodeDefinition)
+      await loadPlugin({
+        id: enabledPluginId,
+        apiVersion: 1,
+        nodes: [enabledDefinition],
+      })
+      await loadPlugin({
+        id: disabledPluginId,
+        apiVersion: 1,
+        nodes: [siteDefinition(disabledKind, () => ({ kind: 'circle', cx: 0, cy: 0, r: 1 }))],
+      })
+
+      const activeSite = {
+        id: activeSiteId,
+        type: 'site',
+        parentId: null,
+        visible: true,
+        children: [
+          'building_active',
+          'site_overlay',
+          'site_overlay_hidden',
+          'site_overlay_disabled',
+        ],
+      } as unknown as AnyNode
+      const activeBuilding = {
+        id: 'building_active',
+        type: 'building',
+        parentId: activeSiteId,
+        children: ['level_active', 'level_upper'],
+        position: [10, 0, 5],
+        rotation: [0, Math.PI / 2, 0],
+      } as unknown as AnyNode
+      const activeLevel = {
+        id: 'level_active',
+        type: 'level',
+        parentId: activeBuilding.id,
+        children: ['level_architecture'],
+      } as unknown as AnyNode
+      const upperLevel = {
+        id: 'level_upper',
+        type: 'level',
+        parentId: activeBuilding.id,
+        children: ['level_upper_architecture'],
+      } as unknown as AnyNode
+      const nodes = {
+        [activeSite.id]: activeSite,
+        [activeBuilding.id]: activeBuilding,
+        [activeLevel.id]: activeLevel,
+        [upperLevel.id]: upperLevel,
+        level_upper_architecture: {
+          id: 'level_upper_architecture',
+          type: architectureKind,
+          parentId: upperLevel.id,
+          visible: true,
+        } as unknown as AnyNode,
+        level_architecture: {
+          id: 'level_architecture',
+          type: architectureKind,
+          parentId: activeLevel.id,
+          visible: true,
+        } as unknown as AnyNode,
+        site_overlay: {
+          id: 'site_overlay',
+          type: enabledKind,
+          parentId: null,
+          children: [semanticChildId],
+          visible: true,
+        } as unknown as AnyNode,
+        [semanticChildId]: {
+          id: semanticChildId,
+          type: 'test:site-detail',
+          parentId: 'site_overlay',
+        } as unknown as AnyNode,
+        [referencedNodeId]: {
+          id: referencedNodeId,
+          type: 'test:site-reference',
+          parentId: activeSiteId,
+        } as unknown as AnyNode,
+        site_overlay_hidden: {
+          id: 'site_overlay_hidden',
+          type: enabledKind,
+          parentId: activeSiteId,
+          visible: false,
+        } as unknown as AnyNode,
+        site_overlay_disabled: {
+          id: 'site_overlay_disabled',
+          type: disabledKind,
+          parentId: activeSiteId,
+          visible: true,
+        } as unknown as AnyNode,
+        [otherSiteId]: {
+          id: otherSiteId,
+          type: 'site',
+          parentId: null,
+          children: ['site_overlay_other'],
+        } as unknown as AnyNode,
+        site_overlay_other: {
+          id: 'site_overlay_other',
+          type: enabledKind,
+          parentId: otherSiteId,
+          visible: true,
+        } as unknown as AnyNode,
+      }
+
+      const full = collectFloorplanGeometry(
+        nodes,
+        activeLevel.id,
+        'full',
+        'metric',
+        'meters',
+        DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        'floor-plan',
+        'finished-faces',
+        [enabledPluginId],
+      )
+
+      expect(full.map(({ id }) => id)).toEqual(['site_overlay', 'level_architecture'])
+      const siteModel = full[0]?.model
+      if (!siteModel) throw new Error('Expected Site geometry')
+      const siteParts = flattenGeometry(siteModel)
+      expect(siteParts).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            kind: 'rect',
+            width: 3,
+            height: 4,
+            fill: '#102030',
+          }),
+          expect.objectContaining({ kind: 'path', fillRule: 'evenodd' }),
+          expect.objectContaining({ kind: 'image', url: inlinePng }),
+        ]),
+      )
+      expect(projectedGeometryPoint(siteModel, 'image')).toEqual([
+        expect.closeTo(2),
+        expect.closeTo(0),
+      ])
+      expect(projectedGeometryPoint(siteModel, 'circle')).toEqual([
+        expect.closeTo(0),
+        expect.closeTo(2),
+      ])
+
+      const rawPdf = new PDFDocument({ autoFirstPage: false, compress: false })
+      const chunks: Buffer[] = []
+      rawPdf.on('data', (chunk: Buffer) => chunks.push(chunk))
+      const completedPdf = Promise.withResolvers<string>()
+      rawPdf.on('end', () => completedPdf.resolve(Buffer.concat(chunks).toString('latin1')))
+      const pdf = new FloorplanPdfDocument(rawPdf, [200, 200])
+      pdf.addPage()
+      for (const { model } of full) {
+        if (!model) continue
+        await renderFloorplanGeometryToPdfKit(pdf, model, {
+          annotationLayer: false,
+          placement: { x: 20, y: 20, width: 100, height: 100 },
+          rotationDeg: 0,
+          viewport: { x: -4, y: -4, width: 20, height: 20 },
+        })
+      }
+      rawPdf.end()
+      const renderedPdf = await completedPdf.promise
+      expect(renderedPdf).toMatch(/f\*/)
+      expect(renderedPdf).toContain('/Subtype /Image')
+
+      const upper = collectFloorplanGeometry(
+        nodes,
+        upperLevel.id,
+        'full',
+        'metric',
+        'meters',
+        DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        'floor-plan',
+        'finished-faces',
+        [enabledPluginId],
+      )
+      expect(upper.map(({ id }) => id)).toEqual(['site_overlay', 'level_upper_architecture'])
+
+      const hiddenSiteNodes = {
+        ...nodes,
+        [activeSite.id]: { ...activeSite, visible: false } as AnyNode,
+      }
+      const hiddenSite = collectFloorplanGeometry(
+        hiddenSiteNodes,
+        activeLevel.id,
+        'full',
+        'metric',
+        'meters',
+        DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        'floor-plan',
+        'finished-faces',
+        [enabledPluginId],
+      )
+      expect(hiddenSite.map(({ id }) => id)).toEqual(['level_architecture'])
+
+      const structure = collectFloorplanGeometry(
+        nodes,
+        activeLevel.id,
+        'structure',
+        'metric',
+        'meters',
+        DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        'floor-plan',
+        'finished-faces',
+        [enabledPluginId],
+      )
+      expect(structure.map(({ id }) => id)).toEqual(['level_architecture'])
+    } finally {
+      restoreRegistry()
+    }
+  })
+})