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

package/src/lib/print-feature-thickness.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from 'bun:test'
+import { type AnyNode, RoofSegmentNode, SlabNode, WallNode } from '@pascal-app/core'
+import type { PrintExportReport } from './print-export'
+import {
+  applySemanticPrintFeatureThickness,
+  measureSemanticPrintFeatureThickness,
+} from './print-feature-thickness'
+
+const nodes = {
+  wall_test: WallNode.parse({
+    id: 'wall_test',
+    parentId: 'level_test',
+    start: [0, 0],
+    end: [4, 0],
+    thickness: 0.2,
+  }),
+  slab_test: SlabNode.parse({
+    id: 'slab_test',
+    parentId: 'level_test',
+    polygon: [
+      [0, 0],
+      [4, 0],
+      [4, 3],
+    ],
+    thickness: 0.25,
+  }),
+  rseg_test: RoofSegmentNode.parse({
+    id: 'rseg_test',
+    parentId: 'level_test',
+    wallThickness: 0.15,
+    deckThickness: 0.12,
+    shingleThickness: 0.03,
+  }),
+} satisfies Record<string, AnyNode>
+
+const report: PrintExportReport = {
+  kind: 'print-export-report',
+  version: 2,
+  format: '3mf',
+  scale: 100,
+  units: 'millimeter',
+  orientation: 'z-up',
+  status: 'pass',
+  bounds: null,
+  triangleCount: 12,
+  invalidTriangleCount: 0,
+  degenerateTriangleCount: 0,
+  boundaryEdgeCount: 0,
+  nonManifoldEdgeCount: 0,
+  connectedComponentCount: 1,
+  solidComponentCount: 1,
+  invertedWinding: false,
+  volumeMm3: 100,
+  diagnostics: [
+    {
+      severity: 'info',
+      code: 'compiler_limits',
+      message: 'Old compiler limit message.',
+    },
+  ],
+}
+
+describe('print feature thickness', () => {
+  test('measures semantic wall, slab, and roof dimensions at print scale', () => {
+    const measurement = measureSemanticPrintFeatureThickness(
+      nodes,
+      ['slab_test', 'rseg_test', 'wall_test'],
+      100,
+    )
+
+    expect(measurement).toEqual({
+      features: [
+        { nodeId: 'rseg_test', thicknessMm: 1.5 },
+        { nodeId: 'slab_test', thicknessMm: 2.5 },
+        { nodeId: 'wall_test', thicknessMm: 2 },
+      ],
+      unmeasuredNodeIds: [],
+    })
+  })
+
+  test('blocks located semantic features below a custom target', () => {
+    const measured = applySemanticPrintFeatureThickness(report, nodes, Object.keys(nodes), 1.8)
+
+    expect(measured.status).toBe('blocked')
+    expect(measured.minimumFeatureThicknessMm).toBeCloseTo(1.5)
+    expect(measured.diagnostics).toContainEqual(
+      expect.objectContaining({
+        code: 'feature_below_target',
+        nodeIds: ['rseg_test'],
+      }),
+    )
+    expect(measured.diagnostics).toContainEqual(
+      expect.objectContaining({
+        code: 'minimum_feature_thickness',
+        nodeIds: ['rseg_test'],
+      }),
+    )
+  })
+
+  test('includes the canonical Dutch top-rake slab in roof measurement', () => {
+    const dutch = RoofSegmentNode.parse({
+      id: 'rseg_dutch-test',
+      parentId: 'level_test',
+      roofType: 'dutch',
+      wallThickness: 0.2,
+      deckThickness: 0.12,
+      shingleThickness: 0.03,
+      dutchTopRakeThickness: 0.05,
+    })
+
+    expect(
+      measureSemanticPrintFeatureThickness({ [dutch.id]: dutch }, [dutch.id], 100).features,
+    ).toEqual([{ nodeId: dutch.id, thicknessMm: 0.5 }])
+  })
+
+  test('does not certify a custom target when source-node coverage is incomplete', () => {
+    const measured = applySemanticPrintFeatureThickness(
+      report,
+      nodes,
+      ['wall_test', 'column_unmeasured'],
+      1.5,
+    )
+
+    expect(measured.status).toBe('blocked')
+    expect(measured.minimumFeatureThicknessMm).toBe(2)
+    expect(measured.diagnostics).toContainEqual(
+      expect.objectContaining({
+        severity: 'error',
+        code: 'feature_thickness_incomplete',
+        nodeIds: ['column_unmeasured'],
+      }),
+    )
+  })
+
+  test('does not certify a custom target from an empty measurement set', () => {
+    const measured = applySemanticPrintFeatureThickness(report, nodes, [], 1.5)
+
+    expect(measured.status).toBe('blocked')
+    expect(measured.minimumFeatureThicknessMm).toBeNull()
+    expect(measured.diagnostics).toContainEqual(
+      expect.objectContaining({
+        severity: 'error',
+        code: 'feature_thickness_incomplete',
+      }),
+    )
+  })
+})

package/src/lib/print-feature-thickness.ts

@@ -0,0 +1,180 @@
+import { type AnyNode, getWallThickness } from '@pascal-app/core'
+import {
+  mergePrintExportDiagnostics,
+  type PrintExportDiagnostic,
+  type PrintExportReport,
+} from './print-export'
+
+const MILLIMETERS_PER_METER = 1000
+
+export type PrintFeatureThickness = {
+  nodeId: string
+  thicknessMm: number
+}
+
+export type PrintFeatureThicknessMeasurement = {
+  features: PrintFeatureThickness[]
+  unmeasuredNodeIds: string[]
+}
+
+const FEATURE_DIAGNOSTIC_CODES = new Set([
+  'minimum_feature_thickness',
+  'feature_below_target',
+  'feature_thickness_incomplete',
+])
+
+function semanticThicknessMeters(node: AnyNode): number | null {
+  switch (node.type) {
+    case 'wall':
+      return getWallThickness(node)
+    case 'slab':
+      return node.thickness
+    case 'roof-segment': {
+      const structuralThicknesses = [node.wallThickness, node.deckThickness + node.shingleThickness]
+      if (node.roofType === 'dutch') structuralThicknesses.push(node.dutchTopRakeThickness)
+      return Math.min(...structuralThicknesses)
+    }
+    default:
+      return null
+  }
+}
+
+function formatThickness(value: number): string {
+  return value
+    .toFixed(3)
+    .replace(/\.000$/, '')
+    .replace(/(\.\d*[1-9])0+$/, '$1')
+}
+
+export function measureSemanticPrintFeatureThickness(
+  nodes: Record<string, AnyNode>,
+  sourceNodeIds: Iterable<string>,
+  scale: number,
+): PrintFeatureThicknessMeasurement {
+  if (!Number.isFinite(scale) || scale <= 0) {
+    throw new RangeError('Print scale must be a positive finite denominator')
+  }
+
+  const features: PrintFeatureThickness[] = []
+  const unmeasuredNodeIds: string[] = []
+  for (const nodeId of Array.from(new Set(sourceNodeIds)).sort()) {
+    const node = nodes[nodeId]
+    const thicknessMeters = node ? semanticThicknessMeters(node) : null
+    if (thicknessMeters === null || !Number.isFinite(thicknessMeters) || thicknessMeters <= 0) {
+      unmeasuredNodeIds.push(nodeId)
+      continue
+    }
+    features.push({
+      nodeId,
+      thicknessMm: (thicknessMeters * MILLIMETERS_PER_METER) / scale,
+    })
+  }
+
+  return { features, unmeasuredNodeIds }
+}
+
+export function applyPrintFeatureThickness(
+  report: PrintExportReport,
+  measurement: PrintFeatureThicknessMeasurement,
+  minimumFeatureMm?: number,
+): PrintExportReport {
+  if (
+    minimumFeatureMm !== undefined &&
+    (!Number.isFinite(minimumFeatureMm) || minimumFeatureMm <= 0)
+  ) {
+    throw new RangeError('Minimum print feature target must be positive and finite')
+  }
+
+  const minimum = measurement.features.reduce<PrintFeatureThickness | null>(
+    (current, feature) =>
+      !current || feature.thicknessMm < current.thicknessMm ? feature : current,
+    null,
+  )
+  const minimumNodeIds = minimum
+    ? measurement.features
+        .filter((feature) => Math.abs(feature.thicknessMm - minimum.thicknessMm) <= 1e-9)
+        .map((feature) => feature.nodeId)
+        .sort()
+    : []
+  const diagnostics: PrintExportDiagnostic[] = [
+    {
+      severity: 'info',
+      code: 'compiler_limits',
+      message:
+        'Known semantic or generated feature dimensions were measured; mesh-observed thin features and self-intersections are not checked.',
+    },
+  ]
+
+  if (minimum) {
+    diagnostics.push({
+      severity: 'info',
+      code: 'minimum_feature_thickness',
+      message: `Minimum known feature thickness is ${formatThickness(minimum.thicknessMm)} mm.`,
+      nodeIds: minimumNodeIds,
+    })
+  }
+
+  if (minimumFeatureMm !== undefined) {
+    const belowTargetNodeIds = measurement.features
+      .filter((feature) => feature.thicknessMm < minimumFeatureMm)
+      .map((feature) => feature.nodeId)
+      .sort()
+    if (belowTargetNodeIds.length > 0) {
+      diagnostics.push({
+        severity: 'error',
+        code: 'feature_below_target',
+        message: `${belowTargetNodeIds.length.toLocaleString()} source node${
+          belowTargetNodeIds.length === 1 ? '' : 's'
+        } fall below the custom ${formatThickness(minimumFeatureMm)} mm feature target; the minimum is ${formatThickness(minimum?.thicknessMm ?? 0)} mm.`,
+        nodeIds: belowTargetNodeIds,
+      })
+    }
+  }
+
+  if (measurement.unmeasuredNodeIds.length > 0) {
+    diagnostics.push({
+      severity: minimumFeatureMm === undefined ? 'warning' : 'error',
+      code: 'feature_thickness_incomplete',
+      message:
+        minimumFeatureMm === undefined
+          ? `Known feature thickness was not measured for ${measurement.unmeasuredNodeIds.length.toLocaleString()} source node${measurement.unmeasuredNodeIds.length === 1 ? '' : 's'}; inspect those features in a slicer.`
+          : `The custom feature target cannot be verified for ${measurement.unmeasuredNodeIds.length.toLocaleString()} source node${measurement.unmeasuredNodeIds.length === 1 ? '' : 's'} without a supported semantic thickness measurement.`,
+      nodeIds: measurement.unmeasuredNodeIds,
+    })
+  } else if (measurement.features.length === 0) {
+    diagnostics.push({
+      severity: minimumFeatureMm === undefined ? 'warning' : 'error',
+      code: 'feature_thickness_incomplete',
+      message:
+        minimumFeatureMm === undefined
+          ? 'No known source feature thickness was available; inspect the part in a slicer.'
+          : 'The custom feature target cannot be verified because no known source feature thickness was available.',
+    })
+  }
+
+  return {
+    ...mergePrintExportDiagnostics(
+      report,
+      diagnostics,
+      new Set(['compiler_limits', 'compiler_pending']),
+    ),
+    minimumFeatureThicknessMm: minimum?.thicknessMm ?? null,
+  }
+}
+
+export function applySemanticPrintFeatureThickness(
+  report: PrintExportReport,
+  nodes: Record<string, AnyNode>,
+  sourceNodeIds: Iterable<string>,
+  minimumFeatureMm?: number,
+): PrintExportReport {
+  return applyPrintFeatureThickness(
+    report,
+    measureSemanticPrintFeatureThickness(nodes, sourceNodeIds, report.scale),
+    minimumFeatureMm,
+  )
+}
+
+export function isPrintFeatureThicknessDiagnostic(diagnostic: PrintExportDiagnostic): boolean {
+  return FEATURE_DIAGNOSTIC_CODES.has(diagnostic.code)
+}

package/src/lib/print-golden-house.test-fixture.ts

@@ -0,0 +1,352 @@
+import {
+  type AnyNode,
+  BuildingNode,
+  DoorNode,
+  getLevelElevations,
+  getWallThickness,
+  LevelNode,
+  nodeRegistry,
+  RoofSegmentNode,
+  registerNode,
+  SlabNode,
+  type SlabPolygonContext,
+  sceneRegistry,
+  WallNode,
+  WindowNode,
+} from '@pascal-app/core'
+import { generateRoofSegmentGeometry, generateSlabGeometry } from '@pascal-app/viewer'
+import * as THREE from 'three'
+
+const EMPTY_SLAB_CONTEXT: SlabPolygonContext = { walls: [], siblingSlabs: [] }
+const PRINT_GOLDEN_FURNITURE_KIND = 'print-golden-furniture'
+
+export const PRINT_GOLDEN_HOUSE_IDS = {
+  building: 'building_print-golden-house',
+  groundLevel: 'level_print-golden-ground',
+  upperLevel: 'level_print-golden-upper',
+  groundWalls: [
+    'wall_print-golden-ground-front',
+    'wall_print-golden-ground-right',
+    'wall_print-golden-ground-back',
+    'wall_print-golden-ground-left',
+  ],
+  upperWalls: [
+    'wall_print-golden-upper-front',
+    'wall_print-golden-upper-right',
+    'wall_print-golden-upper-back',
+    'wall_print-golden-upper-left',
+  ],
+  door: 'door_print-golden-ground-front',
+  window: 'window_print-golden-upper-back',
+  groundSlab: 'slab_print-golden-ground',
+  upperSlab: 'slab_print-golden-upper',
+  roof: 'rseg_print-golden-upper',
+  visibleFurniture: 'furniture_print-golden-visible',
+  hiddenFurnitureParent: 'furniture_print-golden-hidden-parent',
+  hiddenFurnitureChild: 'furniture_print-golden-hidden-child',
+} as const
+
+export type PrintGoldenHouseFixture = {
+  root: THREE.Group
+  nodes: Record<string, AnyNode>
+  structuralNodeIds: string[]
+  groundStructuralNodeIds: string[]
+  upperStructuralNodeIds: string[]
+  dispose: () => void
+}
+
+function wall(
+  id: string,
+  parentId: string,
+  start: [number, number],
+  end: [number, number],
+  children: string[] = [],
+) {
+  return WallNode.parse({
+    id,
+    parentId,
+    start,
+    end,
+    height: 2.5,
+    thickness: 0.2,
+    children,
+  })
+}
+
+function slab(id: string, parentId: string) {
+  return SlabNode.parse({
+    id,
+    parentId,
+    elevation: 0.2,
+    thickness: 0.2,
+    polygon: [
+      [-2.1, -1.6],
+      [2.1, -1.6],
+      [2.1, 1.6],
+      [-2.1, 1.6],
+    ],
+  })
+}
+
+function disposeObject(root: THREE.Object3D) {
+  root.traverse((object) => {
+    const mesh = object as THREE.Mesh
+    if (!mesh.isMesh) return
+    mesh.geometry.dispose()
+    const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material]
+    for (const material of materials) material.dispose()
+  })
+}
+
+export function createPrintGoldenHouseFixture(): PrintGoldenHouseFixture {
+  const ids = PRINT_GOLDEN_HOUSE_IDS
+  for (const kind of ['wall', 'door', 'window', 'slab', 'roof-segment']) {
+    if (nodeRegistry.has(kind)) continue
+    registerNode({
+      kind,
+      schemaVersion: 1,
+      category: 'structure',
+      defaults: () => ({}),
+      capabilities: {},
+    } as never)
+  }
+  const groundWalls = [
+    wall(ids.groundWalls[0], ids.groundLevel, [-2, -1.5], [2, -1.5], [ids.door]),
+    wall(ids.groundWalls[1], ids.groundLevel, [2, -1.5], [2, 1.5]),
+    wall(ids.groundWalls[2], ids.groundLevel, [2, 1.5], [-2, 1.5]),
+    wall(ids.groundWalls[3], ids.groundLevel, [-2, 1.5], [-2, -1.5]),
+  ]
+  const upperWalls = [
+    wall(ids.upperWalls[0], ids.upperLevel, [-2, -1.5], [2, -1.5]),
+    wall(ids.upperWalls[1], ids.upperLevel, [2, -1.5], [2, 1.5]),
+    wall(ids.upperWalls[2], ids.upperLevel, [2, 1.5], [-2, 1.5], [ids.window]),
+    wall(ids.upperWalls[3], ids.upperLevel, [-2, 1.5], [-2, -1.5]),
+  ]
+  const door = DoorNode.parse({
+    id: ids.door,
+    parentId: groundWalls[0]!.id,
+    wallId: groundWalls[0]!.id,
+    position: [2, 1.05, 0],
+    width: 0.9,
+    height: 2.1,
+  })
+  const window = WindowNode.parse({
+    id: ids.window,
+    parentId: upperWalls[2]!.id,
+    wallId: upperWalls[2]!.id,
+    position: [2, 1.4, 0],
+    width: 1.2,
+    height: 1,
+  })
+  const groundSlab = slab(ids.groundSlab, ids.groundLevel)
+  const upperSlab = slab(ids.upperSlab, ids.upperLevel)
+  const roof = RoofSegmentNode.parse({
+    id: ids.roof,
+    parentId: ids.upperLevel,
+    roofType: 'gable',
+    position: [0, 2.5, 0],
+    width: 4,
+    depth: 3,
+    wallHeight: 0.5,
+    pitch: 30,
+    wallThickness: 0.15,
+    deckThickness: 0.1,
+    overhang: 0.3,
+    shingleThickness: 0.05,
+  })
+
+  if (!nodeRegistry.has(PRINT_GOLDEN_FURNITURE_KIND)) {
+    registerNode({
+      kind: PRINT_GOLDEN_FURNITURE_KIND,
+      schemaVersion: 1,
+      category: 'furnish',
+      defaults: () => ({}),
+      capabilities: {},
+    } as never)
+  }
+  const visibleFurniture = {
+    object: 'node',
+    id: ids.visibleFurniture,
+    type: PRINT_GOLDEN_FURNITURE_KIND,
+    parentId: ids.groundLevel,
+    children: [],
+    visible: true,
+  } as unknown as AnyNode
+  const hiddenFurnitureParent = {
+    object: 'node',
+    id: ids.hiddenFurnitureParent,
+    type: PRINT_GOLDEN_FURNITURE_KIND,
+    parentId: ids.groundLevel,
+    children: [ids.hiddenFurnitureChild],
+    visible: false,
+  } as unknown as AnyNode
+  const hiddenFurnitureChild = {
+    object: 'node',
+    id: ids.hiddenFurnitureChild,
+    type: PRINT_GOLDEN_FURNITURE_KIND,
+    parentId: ids.hiddenFurnitureParent,
+    children: [],
+    visible: true,
+  } as unknown as AnyNode
+
+  const groundLevel = LevelNode.parse({
+    id: ids.groundLevel,
+    parentId: ids.building,
+    name: 'Ground',
+    level: 0,
+    height: 2.5,
+    children: [
+      ...groundWalls.map((node) => node.id),
+      groundSlab.id,
+      visibleFurniture.id,
+      hiddenFurnitureParent.id,
+    ],
+  })
+  const upperLevel = LevelNode.parse({
+    id: ids.upperLevel,
+    parentId: ids.building,
+    name: 'Upper',
+    level: 1,
+    height: 2.5,
+    children: [...upperWalls.map((node) => node.id), upperSlab.id, roof.id],
+  })
+  const building = BuildingNode.parse({
+    id: ids.building,
+    children: [groundLevel.id, upperLevel.id],
+  })
+  const nodes = Object.fromEntries(
+    [
+      building,
+      groundLevel,
+      upperLevel,
+      ...groundWalls,
+      ...upperWalls,
+      door,
+      window,
+      groundSlab,
+      upperSlab,
+      roof,
+      visibleFurniture,
+      hiddenFurnitureParent,
+      hiddenFurnitureChild,
+    ].map((node) => [node.id, node]),
+  ) as Record<string, AnyNode>
+
+  const root = new THREE.Group()
+  root.name = 'print-golden-house'
+  const buildingRoot = new THREE.Group()
+  buildingRoot.userData = { pascalId: building.id }
+  const groundRoot = new THREE.Group()
+  groundRoot.userData = { pascalId: groundLevel.id }
+  const upperRoot = new THREE.Group()
+  upperRoot.userData = { pascalId: upperLevel.id }
+  const elevations = getLevelElevations(nodes)
+  groundRoot.position.y = elevations.get(groundLevel.id)?.baseY ?? 0
+  upperRoot.position.y = elevations.get(upperLevel.id)?.baseY ?? 0
+  root.add(buildingRoot)
+  buildingRoot.add(groundRoot, upperRoot)
+
+  const registered = new Map<string, THREE.Object3D>()
+  const registerObject = (id: string, object: THREE.Object3D) => {
+    sceneRegistry.nodes.set(id, object)
+    registered.set(id, object)
+  }
+  registerObject(building.id, buildingRoot)
+  registerObject(groundLevel.id, groundRoot)
+  registerObject(upperLevel.id, upperRoot)
+
+  const mountWalls = (
+    levelRoot: THREE.Group,
+    walls: WallNode[],
+    openings: Array<typeof door | typeof window>,
+  ) => {
+    for (const wallNode of walls) {
+      const wallRoot = new THREE.Group()
+      wallRoot.userData = { pascalId: wallNode.id }
+      wallRoot.position.set(wallNode.start[0], 0, wallNode.start[1])
+      wallRoot.rotation.y = -Math.atan2(
+        wallNode.end[1] - wallNode.start[1],
+        wallNode.end[0] - wallNode.start[0],
+      )
+      const wallOpenings = openings.filter((opening) => opening.wallId === wallNode.id)
+      const wallLength = Math.hypot(
+        wallNode.end[0] - wallNode.start[0],
+        wallNode.end[1] - wallNode.start[1],
+      )
+      const wallHeight = wallNode.height ?? 2.5
+      const displayWall = new THREE.Mesh(
+        new THREE.BoxGeometry(wallLength, wallHeight, getWallThickness(wallNode)),
+      )
+      displayWall.position.set(wallLength / 2, wallHeight / 2, 0)
+      wallRoot.add(displayWall)
+      for (const opening of wallOpenings) {
+        const openingRoot = new THREE.Group()
+        openingRoot.userData = { pascalId: opening.id }
+        wallRoot.add(openingRoot)
+        registerObject(opening.id, openingRoot)
+      }
+      levelRoot.add(wallRoot)
+      registerObject(wallNode.id, wallRoot)
+    }
+  }
+  mountWalls(groundRoot, groundWalls, [door])
+  mountWalls(upperRoot, upperWalls, [window])
+
+  const mountSlab = (levelRoot: THREE.Group, node: SlabNode) => {
+    const slabRoot = new THREE.Group()
+    slabRoot.userData = { pascalId: node.id }
+    slabRoot.add(new THREE.Mesh(generateSlabGeometry(node, EMPTY_SLAB_CONTEXT)))
+    levelRoot.add(slabRoot)
+    registerObject(node.id, slabRoot)
+  }
+  mountSlab(groundRoot, groundSlab)
+  mountSlab(upperRoot, upperSlab)
+
+  const roofRoot = new THREE.Group()
+  roofRoot.userData = { pascalId: roof.id }
+  roofRoot.position.set(...roof.position)
+  roofRoot.add(new THREE.Mesh(generateRoofSegmentGeometry(roof)))
+  upperRoot.add(roofRoot)
+  registerObject(roof.id, roofRoot)
+
+  const visibleFurnitureRoot = new THREE.Group()
+  visibleFurnitureRoot.userData = { pascalId: visibleFurniture.id }
+  visibleFurnitureRoot.position.set(1, 0.5, 0)
+  visibleFurnitureRoot.add(new THREE.Mesh(new THREE.BoxGeometry(0.8, 1, 0.8)))
+  groundRoot.add(visibleFurnitureRoot)
+  registerObject(visibleFurniture.id, visibleFurnitureRoot)
+
+  const hiddenFurnitureParentRoot = new THREE.Group()
+  hiddenFurnitureParentRoot.userData = { pascalId: hiddenFurnitureParent.id }
+  hiddenFurnitureParentRoot.position.set(-1, 0, 0)
+  const hiddenFurnitureChildRoot = new THREE.Group()
+  hiddenFurnitureChildRoot.userData = { pascalId: hiddenFurnitureChild.id }
+  hiddenFurnitureChildRoot.position.y = 0.5
+  hiddenFurnitureChildRoot.add(new THREE.Mesh(new THREE.BoxGeometry(0.8, 1, 0.8)))
+  hiddenFurnitureParentRoot.add(hiddenFurnitureChildRoot)
+  groundRoot.add(hiddenFurnitureParentRoot)
+  registerObject(hiddenFurnitureParent.id, hiddenFurnitureParentRoot)
+  registerObject(hiddenFurnitureChild.id, hiddenFurnitureChildRoot)
+
+  const groundStructuralNodeIds = [...groundWalls.map((node) => node.id), groundSlab.id].sort()
+  const upperStructuralNodeIds = [
+    ...upperWalls.map((node) => node.id),
+    upperSlab.id,
+    roof.id,
+  ].sort()
+
+  return {
+    root,
+    nodes,
+    structuralNodeIds: [...groundStructuralNodeIds, ...upperStructuralNodeIds].sort(),
+    groundStructuralNodeIds,
+    upperStructuralNodeIds,
+    dispose: () => {
+      for (const [id, object] of registered) {
+        if (sceneRegistry.nodes.get(id) === object) sceneRegistry.nodes.delete(id)
+      }
+      disposeObject(root)
+      root.clear()
+    },
+  }
+}