@ifc-lite/viewer 1.8.0 → 1.10.0

package/src/lib/scripts/templates/federation-compare.ts

@@ -0,0 +1,189 @@
+export {} // module boundary (stripped by transpiler)
+
+// ── Multi-Model Federation Comparison ───────────────────────────────────
+// Stakeholder: Project Manager / BIM Coordinator
+//
+// When multiple IFC models are loaded (architectural + structural + MEP),
+// this script compares them side by side: entity counts, type coverage,
+// naming consistency, and property completeness per model. The UI shows
+// one tree at a time — this script cross-references everything and
+// highlights discrepancies that indicate coordination issues.
+// ─────────────────────────────────────────────────────────────────────────
+
+const models = bim.model.list()
+
+if (models.length === 0) {
+  console.error('No models loaded')
+  throw new Error('no models')
+}
+
+console.log('═══════════════════════════════════════')
+console.log('  FEDERATION COMPARISON')
+console.log('═══════════════════════════════════════')
+console.log('')
+
+// ── 1. Model overview ───────────────────────────────────────────────────
+console.log('── Loaded Models (' + models.length + ') ──')
+let totalEntities = 0
+for (const m of models) {
+  const sizeMB = (m.fileSize / 1024 / 1024).toFixed(1)
+  console.log('  [' + m.id.slice(0, 8) + '] ' + m.name)
+  console.log('    Schema: ' + m.schemaVersion + '  |  Entities: ' + m.entityCount + '  |  Size: ' + sizeMB + ' MB')
+  totalEntities += m.entityCount
+}
+console.log('')
+console.log('Total: ' + totalEntities + ' entities across ' + models.length + ' models')
+
+// ── 2. Type distribution per model ──────────────────────────────────────
+const all = bim.query.all()
+
+// Build type→model distribution
+const typeByModel: Record<string, Record<string, number>> = {}
+const modelEntityMap: Record<string, BimEntity[]> = {}
+for (const e of all) {
+  const mid = e.ref.modelId
+  if (!modelEntityMap[mid]) modelEntityMap[mid] = []
+  modelEntityMap[mid].push(e)
+
+  if (!typeByModel[e.Type]) typeByModel[e.Type] = {}
+  typeByModel[e.Type][mid] = (typeByModel[e.Type][mid] || 0) + 1
+}
+
+// Find types that exist in multiple models (potential overlaps/conflicts)
+const sharedTypes: string[] = []
+const exclusiveTypes: Record<string, string[]> = {} // modelId → types only in that model
+
+for (const [type, distribution] of Object.entries(typeByModel)) {
+  const modelIds = Object.keys(distribution)
+  if (modelIds.length > 1) {
+    sharedTypes.push(type)
+  } else {
+    const mid = modelIds[0]
+    if (!exclusiveTypes[mid]) exclusiveTypes[mid] = []
+    exclusiveTypes[mid].push(type)
+  }
+}
+
+console.log('')
+console.log('── Type Distribution ──')
+console.log('')
+
+// Types present in multiple models
+if (sharedTypes.length > 0) {
+  console.log('Types shared across models (' + sharedTypes.length + '):')
+  const header = '  Type                         ' + models.map(m => ('| ' + m.name.slice(0, 10) + '          ').slice(0, 13)).join('')
+  console.log(header)
+  console.log('  ' + '-'.repeat(header.length - 2))
+
+  for (const type of sharedTypes.sort((a, b) => {
+    const totalA = Object.values(typeByModel[a]).reduce((s, v) => s + v, 0)
+    const totalB = Object.values(typeByModel[b]).reduce((s, v) => s + v, 0)
+    return totalB - totalA
+  }).slice(0, 20)) {
+    const typeStr = (type + '                              ').slice(0, 30)
+    const counts = models.map(m => {
+      const c = typeByModel[type][m.id] || 0
+      return ('| ' + (c > 0 ? String(c) : '-') + '           ').slice(0, 13)
+    }).join('')
+    console.log('  ' + typeStr + counts)
+  }
+}
+
+// Types exclusive to one model
+console.log('')
+console.log('Types exclusive to one model:')
+for (const m of models) {
+  const exclusive = exclusiveTypes[m.id] || []
+  if (exclusive.length > 0) {
+    console.log('  ' + m.name + ': ' + exclusive.slice(0, 8).join(', ') + (exclusive.length > 8 ? ' (+' + (exclusive.length - 8) + ' more)' : ''))
+  }
+}
+
+// ── 3. Naming consistency check ─────────────────────────────────────────
+console.log('')
+console.log('── Naming Consistency ──')
+for (const m of models) {
+  const entities = modelEntityMap[m.id] || []
+  const named = entities.filter(e => e.Name && e.Name !== '')
+  const described = entities.filter(e => e.Description && e.Description !== '')
+  const typed = entities.filter(e => e.ObjectType && e.ObjectType !== '')
+  const namePct = entities.length > 0 ? (named.length / entities.length * 100).toFixed(1) : '0'
+  const descPct = entities.length > 0 ? (described.length / entities.length * 100).toFixed(1) : '0'
+  const typePct = entities.length > 0 ? (typed.length / entities.length * 100).toFixed(1) : '0'
+  console.log('  ' + m.name + ':')
+  console.log('    Named: ' + namePct + '%  |  Described: ' + descPct + '%  |  ObjectType: ' + typePct + '%')
+}
+
+// ── 4. Property coverage comparison ─────────────────────────────────────
+console.log('')
+console.log('── Property Coverage (sample of 100 per model) ──')
+for (const m of models) {
+  const entities = modelEntityMap[m.id] || []
+  const sample = entities.slice(0, 100)
+  let withPsets = 0
+  let withQsets = 0
+  let totalPsets = 0
+  for (const e of sample) {
+    const psets = bim.query.properties(e)
+    const qsets = bim.query.quantities(e)
+    if (psets.length > 0) withPsets++
+    if (qsets.length > 0) withQsets++
+    totalPsets += psets.length
+  }
+  const psetPct = sample.length > 0 ? (withPsets / sample.length * 100).toFixed(0) : '0'
+  const qsetPct = sample.length > 0 ? (withQsets / sample.length * 100).toFixed(0) : '0'
+  const avgPsets = sample.length > 0 ? (totalPsets / sample.length).toFixed(1) : '0'
+  console.log('  ' + m.name + ':')
+  console.log('    With properties: ' + psetPct + '%  |  With quantities: ' + qsetPct + '%  |  Avg psets/entity: ' + avgPsets)
+}
+
+// ── 5. Potential coordination issues ────────────────────────────────────
+if (models.length > 1) {
+  console.log('')
+  console.log('── Coordination Notes ──')
+
+  // Check for spatial types in non-architectural models
+  const spatialTypes = ['IfcBuilding', 'IfcBuildingStorey', 'IfcSite', 'IfcSpace']
+  for (const m of models) {
+    const hasSpatial: string[] = []
+    for (const st of spatialTypes) {
+      if (typeByModel[st] && typeByModel[st][m.id]) {
+        hasSpatial.push(st + '(' + typeByModel[st][m.id] + ')')
+      }
+    }
+    if (hasSpatial.length > 0) {
+      console.log('  ' + m.name + ' defines: ' + hasSpatial.join(', '))
+    }
+  }
+
+  // Check entity count ratios (large disparities may indicate issues)
+  const counts = models.map(m => modelEntityMap[m.id]?.length || 0)
+  const maxCount = Math.max(...counts)
+  const minCount = Math.min(...counts)
+  if (maxCount > 0 && minCount > 0 && maxCount / minCount > 10) {
+    console.warn('')
+    console.warn('  Large entity count disparity (' + maxCount + ' vs ' + minCount + ')')
+    console.warn('  This may indicate models at different levels of detail')
+  }
+}
+
+// ── 6. Color-code by model origin ───────────────────────────────────────
+const modelColors = ['#e74c3c', '#3498db', '#2ecc71', '#f39c12', '#9b59b6', '#1abc9c']
+const colorBatches: Array<{ entities: BimEntity[]; color: string }> = []
+let idx = 0
+for (const m of models) {
+  const entities = modelEntityMap[m.id] || []
+  if (entities.length > 0) {
+    colorBatches.push({ entities, color: modelColors[idx % modelColors.length] })
+    idx++
+  }
+}
+if (colorBatches.length > 0) bim.viewer.colorizeAll(colorBatches)
+
+console.log('')
+console.log('── Model Colors ──')
+idx = 0
+for (const m of models) {
+  console.log('  ' + m.name + '  ● ' + modelColors[idx % modelColors.length])
+  idx++
+}

package/src/lib/scripts/templates/fire-safety-check.ts

@@ -0,0 +1,161 @@
+export {} // module boundary (stripped by transpiler)
+
+// ── Fire Safety Compliance Check ────────────────────────────────────────
+// Stakeholder: Architect / Fire Safety Engineer
+//
+// Cross-references fire rating properties across walls and doors — a task
+// that requires clicking through hundreds of entities in the properties
+// panel. The script checks Pset_WallCommon.FireRating and
+// Pset_DoorCommon.FireRating, flags missing or non-compliant values,
+// color-codes the model by compliance status, and generates a report.
+// ─────────────────────────────────────────────────────────────────────────
+
+bim.viewer.resetColors()
+
+// ── 1. Gather fire-rated element types ──────────────────────────────────
+const walls = bim.query.byType('IfcWall', 'IfcWallStandardCase')
+const doors = bim.query.byType('IfcDoor', 'IfcDoorStandardCase')
+const slabs = bim.query.byType('IfcSlab')
+const total = walls.length + doors.length + slabs.length
+
+if (total === 0) {
+  console.error('No walls, doors, or slabs found in model')
+  throw new Error('no elements')
+}
+
+// ── 2. Extract fire rating from properties ──────────────────────────────
+interface FireResult {
+  entity: BimEntity
+  rating: string | null
+  isLoadBearing: boolean | null
+  isExternal: boolean | null
+}
+
+// Collect fire-related property paths for CSV export
+const firePropPaths = new Set<string>()
+
+function extractFireData(entity: BimEntity): FireResult {
+  const result: FireResult = { entity, rating: null, isLoadBearing: null, isExternal: null }
+  const psets = bim.query.properties(entity)
+  for (const pset of psets) {
+    for (const p of pset.properties) {
+      const lower = p.name.toLowerCase()
+      if (lower === 'firerating' && p.value !== null && p.value !== '') {
+        result.rating = String(p.value)
+        firePropPaths.add(pset.name + '.FireRating')
+      }
+      if (lower === 'loadbearing' && p.value !== null) {
+        result.isLoadBearing = p.value === true || p.value === 'TRUE' || p.value === '.T.'
+        firePropPaths.add(pset.name + '.LoadBearing')
+      }
+      if (lower === 'isexternal' && p.value !== null) {
+        result.isExternal = p.value === true || p.value === 'TRUE' || p.value === '.T.'
+        firePropPaths.add(pset.name + '.IsExternal')
+      }
+    }
+  }
+  return result
+}
+
+// ── 3. Analyze each element category ────────────────────────────────────
+const wallResults = walls.map(extractFireData)
+const doorResults = doors.map(extractFireData)
+const slabResults = slabs.map(extractFireData)
+
+// Classify
+const rated: BimEntity[] = []
+const unrated: BimEntity[] = []
+const loadBearingUnrated: BimEntity[] = []
+const externalUnrated: BimEntity[] = []
+
+for (const r of [...wallResults, ...doorResults, ...slabResults]) {
+  if (r.rating) {
+    rated.push(r.entity)
+  } else {
+    unrated.push(r.entity)
+    if (r.isLoadBearing) loadBearingUnrated.push(r.entity)
+    if (r.isExternal) externalUnrated.push(r.entity)
+  }
+}
+
+// ── 4. Group by fire rating value ───────────────────────────────────────
+const ratingGroups: Record<string, BimEntity[]> = {}
+for (const r of [...wallResults, ...doorResults, ...slabResults]) {
+  if (r.rating) {
+    if (!ratingGroups[r.rating]) ratingGroups[r.rating] = []
+    ratingGroups[r.rating].push(r.entity)
+  }
+}
+
+// ── 5. Color-code by compliance ─────────────────────────────────────────
+const batches: Array<{ entities: BimEntity[]; color: string }> = []
+if (rated.length > 0) batches.push({ entities: rated, color: '#27ae60' })           // green = rated
+if (loadBearingUnrated.length > 0) batches.push({ entities: loadBearingUnrated, color: '#e74c3c' }) // red = critical
+if (externalUnrated.length > 0) batches.push({ entities: externalUnrated, color: '#e67e22' })       // orange = warning
+// Remaining unrated that are not load-bearing or external
+const otherUnrated = unrated.filter(e => {
+  const isLB = loadBearingUnrated.some(lb => lb.GlobalId === e.GlobalId)
+  const isExt = externalUnrated.some(ext => ext.GlobalId === e.GlobalId)
+  return !isLB && !isExt
+})
+if (otherUnrated.length > 0) batches.push({ entities: otherUnrated, color: '#f1c40f' }) // yellow = missing
+if (batches.length > 0) bim.viewer.colorizeAll(batches)
+
+// ── 6. Report ───────────────────────────────────────────────────────────
+const compliancePct = (rated.length / total * 100).toFixed(1)
+console.log('═══════════════════════════════════════')
+console.log('  FIRE SAFETY COMPLIANCE CHECK')
+console.log('═══════════════════════════════════════')
+console.log('')
+console.log('Scanned: ' + walls.length + ' walls, ' + doors.length + ' doors, ' + slabs.length + ' slabs')
+console.log('Compliance: ' + compliancePct + '% (' + rated.length + '/' + total + ' rated)')
+console.log('')
+console.log('  ● Rated:                    ' + rated.length + '  green')
+console.log('  ● Missing (load-bearing):   ' + loadBearingUnrated.length + '  red — CRITICAL')
+console.log('  ● Missing (external):       ' + externalUnrated.length + '  orange — WARNING')
+console.log('  ● Missing (other):          ' + otherUnrated.length + '  yellow')
+
+// ── 7. Rating distribution ──────────────────────────────────────────────
+if (Object.keys(ratingGroups).length > 0) {
+  console.log('')
+  console.log('── Fire Rating Distribution ──')
+  const ratingsSorted = Object.entries(ratingGroups).sort((a, b) => b[1].length - a[1].length)
+  for (const [rating, entities] of ratingsSorted) {
+    console.log('  ' + rating + ': ' + entities.length + ' elements')
+  }
+}
+
+// ── 8. Per-type breakdown ───────────────────────────────────────────────
+console.log('')
+console.log('── Breakdown by Element Type ──')
+const typeGroups: Record<string, { rated: number; total: number }> = {}
+for (const r of [...wallResults, ...doorResults, ...slabResults]) {
+  const t = r.entity.Type
+  if (!typeGroups[t]) typeGroups[t] = { rated: 0, total: 0 }
+  typeGroups[t].total++
+  if (r.rating) typeGroups[t].rated++
+}
+for (const [type, g] of Object.entries(typeGroups).sort((a, b) => b[1].total - a[1].total)) {
+  const pct = (g.rated / g.total * 100).toFixed(0)
+  console.log('  ' + type + ': ' + g.rated + '/' + g.total + ' rated (' + pct + '%)')
+}
+
+// ── 9. Critical issues list ─────────────────────────────────────────────
+if (loadBearingUnrated.length > 0) {
+  console.log('')
+  console.warn('── CRITICAL: Load-Bearing Without Fire Rating ──')
+  for (const e of loadBearingUnrated.slice(0, 15)) {
+    console.warn('  ' + (e.Name || '<unnamed>') + ' [' + e.Type + '] GlobalId=' + e.GlobalId)
+  }
+  if (loadBearingUnrated.length > 15) console.warn('  ... and ' + (loadBearingUnrated.length - 15) + ' more')
+}
+
+// ── 10. Export all scanned elements with fire properties ────────────────
+const allFireElements = [...walls, ...doors, ...slabs]
+const fireCols = Array.from(firePropPaths).sort()
+bim.export.csv(allFireElements, {
+  columns: ['Name', 'Type', 'GlobalId', 'ObjectType', ...fireCols],
+  filename: 'fire-safety-report.csv'
+})
+console.log('')
+console.log('Exported ' + allFireElements.length + ' elements (' + (4 + fireCols.length) + ' columns) to fire-safety-report.csv')

package/src/lib/scripts/templates/mep-equipment-schedule.ts

@@ -0,0 +1,175 @@
+export {} // module boundary (stripped by transpiler)
+
+// ── MEP Equipment Schedule ──────────────────────────────────────────────
+// Stakeholder: HVAC / MEP Engineer
+//
+// Discovers all MEP/distribution elements in the model, extracts their
+// properties (manufacturer, model, capacity, pressure, flow rate), and
+// generates a structured equipment register. The UI's property panel
+// shows one element at a time — this script scans hundreds of elements
+// and builds the schedule that would otherwise require a spreadsheet.
+// ─────────────────────────────────────────────────────────────────────────
+
+// ── 1. Query all MEP-related IFC types ──────────────────────────────────
+const MEP_TYPES = [
+  // HVAC
+  'IfcAirTerminal', 'IfcAirTerminalBox', 'IfcFan', 'IfcCoil', 'IfcCompressor',
+  'IfcCondenser', 'IfcCooledBeam', 'IfcCoolingTower', 'IfcEvaporativeCooler',
+  'IfcEvaporator', 'IfcHeatExchanger', 'IfcHumidifier', 'IfcUnitaryEquipment',
+  'IfcBoiler', 'IfcChiller', 'IfcAirToAirHeatRecovery',
+  // Plumbing
+  'IfcSanitaryTerminal', 'IfcWasteTerminal', 'IfcFireSuppressionTerminal',
+  'IfcTank', 'IfcPump', 'IfcValve',
+  // Electrical
+  'IfcElectricDistributionBoard', 'IfcElectricGenerator', 'IfcElectricMotor',
+  'IfcTransformer', 'IfcSwitchingDevice', 'IfcOutlet', 'IfcLightFixture',
+  'IfcLamp', 'IfcJunctionBox',
+  // Generic distribution
+  'IfcDistributionElement', 'IfcDistributionControlElement',
+  'IfcDistributionFlowElement', 'IfcFlowTerminal', 'IfcFlowMovingDevice',
+  'IfcFlowController', 'IfcFlowStorageDevice', 'IfcFlowTreatmentDevice',
+  'IfcFlowFitting', 'IfcFlowSegment', 'IfcEnergyConversionDevice',
+  // Segments
+  'IfcDuctSegment', 'IfcPipeSegment', 'IfcCableCarrierSegment', 'IfcCableSegment',
+  'IfcDuctFitting', 'IfcPipeFitting', 'IfcCableCarrierFitting',
+  // Furnishing (often used for MEP equipment in some models)
+  'IfcFurnishingElement',
+]
+
+const elements = bim.query.byType(...MEP_TYPES)
+
+if (elements.length === 0) {
+  // Fall back: show what types ARE in the model so user can adapt
+  console.warn('No standard MEP element types found.')
+  console.log('')
+  console.log('Available types in this model:')
+  const all = bim.query.all()
+  const types: Record<string, number> = {}
+  for (const e of all) types[e.Type] = (types[e.Type] || 0) + 1
+  for (const [t, c] of Object.entries(types).sort((a, b) => b[1] - a[1])) {
+    console.log('  ' + t + ': ' + c)
+  }
+  console.log('')
+  console.log('Tip: edit MEP_TYPES at top of script to match your model\'s types.')
+  throw new Error('no MEP elements')
+}
+
+// ── 2. Group by IFC type ────────────────────────────────────────────────
+const byType: Record<string, BimEntity[]> = {}
+for (const e of elements) {
+  if (!byType[e.Type]) byType[e.Type] = []
+  byType[e.Type].push(e)
+}
+
+console.log('═══════════════════════════════════════')
+console.log('  MEP EQUIPMENT SCHEDULE')
+console.log('═══════════════════════════════════════')
+console.log('')
+console.log('Found ' + elements.length + ' MEP elements across ' + Object.keys(byType).length + ' types')
+
+// ── 3. Extract properties for each type ─────────────────────────────────
+// Properties of interest for MEP equipment
+const MEP_PROPS = [
+  'manufacturer', 'model', 'reference', 'status',
+  'capacity', 'power', 'voltage', 'current', 'frequency',
+  'flowrate', 'pressure', 'temperature',
+  'nominalcapacity', 'nominalpower',
+]
+
+interface EquipmentEntry {
+  entity: BimEntity
+  props: Record<string, string | number | boolean | null>
+}
+
+const schedule: Record<string, EquipmentEntry[]> = {}
+// Collect all unique property paths for CSV export columns
+const propertyColumns = new Set<string>()
+
+for (const [type, entities] of Object.entries(byType).sort((a, b) => b[1].length - a[1].length)) {
+  schedule[type] = []
+
+  // Cap property extraction at 200 per type
+  const sample = entities.length > 200 ? entities.slice(0, 200) : entities
+
+  for (const entity of sample) {
+    const entry: EquipmentEntry = { entity, props: {} }
+    const psets = bim.query.properties(entity)
+    for (const pset of psets) {
+      for (const p of pset.properties) {
+        const lower = p.name.toLowerCase()
+        if (MEP_PROPS.some(k => lower.includes(k)) && p.value !== null && p.value !== '') {
+          const path = pset.name + '.' + p.name
+          entry.props[path] = p.value
+          propertyColumns.add(path)
+        }
+      }
+    }
+    schedule[type].push(entry)
+  }
+}
+
+// ── 4. Print schedule ───────────────────────────────────────────────────
+for (const [type, entries] of Object.entries(schedule).sort((a, b) => b[1].length - a[1].length)) {
+  console.log('')
+  console.log('── ' + type + ' (' + byType[type].length + ') ──')
+
+  // Collect all property keys found in this type
+  const allKeys = new Set<string>()
+  for (const entry of entries) {
+    for (const key of Object.keys(entry.props)) allKeys.add(key)
+  }
+
+  if (allKeys.size === 0) {
+    // Show name grouping even without properties
+    const names: Record<string, number> = {}
+    for (const entry of entries) {
+      const key = entry.entity.Name || entry.entity.ObjectType || '<unnamed>'
+      names[key] = (names[key] || 0) + 1
+    }
+    for (const [name, count] of Object.entries(names).sort((a, b) => b[1] - a[1])) {
+      console.log('  ' + name + (count > 1 ? ' (x' + count + ')' : ''))
+    }
+  } else {
+    // Show first 10 entries with their properties
+    for (const entry of entries.slice(0, 10)) {
+      const label = entry.entity.Name || entry.entity.ObjectType || '<unnamed>'
+      console.log('  ' + label)
+      for (const [key, value] of Object.entries(entry.props)) {
+        console.log('    ' + key + ' = ' + value)
+      }
+    }
+    if (entries.length > 10) console.log('  ... and ' + (entries.length - 10) + ' more')
+  }
+}
+
+// ── 5. Color-code by system type ────────────────────────────────────────
+const palette = [
+  '#e74c3c', '#3498db', '#2ecc71', '#f39c12',
+  '#9b59b6', '#1abc9c', '#e67e22', '#34495e',
+]
+const batches: Array<{ entities: BimEntity[]; color: string }> = []
+let colorIdx = 0
+for (const [type, entities] of Object.entries(byType).sort((a, b) => b[1].length - a[1].length)) {
+  batches.push({ entities, color: palette[colorIdx % palette.length] })
+  colorIdx++
+}
+bim.viewer.colorizeAll(batches)
+bim.viewer.isolate(elements)
+
+// ── 6. Summary ──────────────────────────────────────────────────────────
+console.log('')
+console.log('── Type Summary ──')
+for (const [type, entities] of Object.entries(byType).sort((a, b) => b[1].length - a[1].length)) {
+  const color = palette[(Object.keys(byType).sort((a, b) => byType[b].length - byType[a].length).indexOf(type)) % palette.length]
+  console.log('  ' + type + ': ' + entities.length + '  ● ' + color)
+}
+
+// ── 7. Export ────────────────────────────────────────────────────────────
+const propCols = Array.from(propertyColumns).sort()
+bim.export.csv(elements, {
+  columns: ['Name', 'Type', 'ObjectType', 'GlobalId', 'Description', ...propCols],
+  filename: 'mep-equipment-schedule.csv'
+})
+console.log('')
+console.log('Exported ' + elements.length + ' MEP elements (' + (5 + propCols.length) + ' columns) to mep-equipment-schedule.csv')
+console.log('Elements are isolated and color-coded by type in 3D view')

package/src/lib/scripts/templates/quantity-takeoff.ts

@@ -0,0 +1,145 @@
+export {} // module boundary (stripped by transpiler)
+
+// ── Quantity Takeoff ────────────────────────────────────────────────────
+// Stakeholder: Cost Estimator / Project Manager
+//
+// Aggregates quantities (area, volume, length, width, height) across all
+// structural and architectural element types. This combines what would
+// require opening the properties panel for each element individually,
+// manually recording numbers, and aggregating in a spreadsheet. The
+// script does it in seconds and exports a ready-to-use CSV.
+// ─────────────────────────────────────────────────────────────────────────
+
+const ELEMENT_TYPES = [
+  'IfcWall', 'IfcWallStandardCase',
+  'IfcSlab',
+  'IfcColumn',
+  'IfcBeam',
+  'IfcDoor', 'IfcDoorStandardCase',
+  'IfcWindow',
+  'IfcCovering',
+  'IfcCurtainWall',
+  'IfcRoof',
+  'IfcStair', 'IfcStairFlight',
+  'IfcRailing',
+  'IfcPlate',
+  'IfcMember',
+  'IfcFooting',
+  'IfcPile',
+]
+
+// Quantities we care about (case-insensitive matching)
+const QTY_KEYS = ['area', 'volume', 'length', 'width', 'height', 'netarea', 'netsidearea', 'netvolume', 'grossarea', 'grossvolume', 'perimeter']
+
+interface TypeTakeoff {
+  type: string
+  count: number
+  quantities: Record<string, { sum: number; count: number; unit: string }>
+}
+
+console.log('═══════════════════════════════════════')
+console.log('  QUANTITY TAKEOFF')
+console.log('═══════════════════════════════════════')
+console.log('')
+
+const takeoffs: TypeTakeoff[] = []
+let totalElements = 0
+// Collect all unique Qto set+quantity paths for CSV export columns
+const quantityColumns = new Set<string>()
+
+for (const ifcType of ELEMENT_TYPES) {
+  const entities = bim.query.byType(ifcType)
+  if (entities.length === 0) continue
+
+  totalElements += entities.length
+  const takeoff: TypeTakeoff = { type: ifcType, count: entities.length, quantities: {} }
+
+  // Sample all entities for quantities (cap at 500 to avoid timeout)
+  const sample = entities.length > 500 ? entities.slice(0, 500) : entities
+  const isSampled = entities.length > 500
+
+  for (const entity of sample) {
+    const qsets = bim.query.quantities(entity)
+    for (const qset of qsets) {
+      for (const q of qset.quantities) {
+        if (q.value === null || q.value === 0) continue
+        const lower = q.name.toLowerCase()
+        // Only aggregate quantities we care about
+        const match = QTY_KEYS.find(k => lower.includes(k))
+        if (!match) continue
+        const key = q.name
+        if (!takeoff.quantities[key]) takeoff.quantities[key] = { sum: 0, count: 0, unit: '' }
+        takeoff.quantities[key].sum += q.value
+        takeoff.quantities[key].count++
+        // Track the full path for CSV export
+        quantityColumns.add(qset.name + '.' + q.name)
+      }
+    }
+  }
+
+  // Scale up if sampled
+  if (isSampled) {
+    const factor = entities.length / sample.length
+    for (const q of Object.values(takeoff.quantities)) {
+      q.sum = q.sum * factor
+    }
+  }
+
+  takeoffs.push(takeoff)
+}
+
+if (takeoffs.length === 0) {
+  console.error('No elements with quantities found')
+  throw new Error('no quantities')
+}
+
+// ── Report ──────────────────────────────────────────────────────────────
+console.log('Scanned ' + totalElements + ' elements across ' + takeoffs.length + ' types')
+console.log('')
+
+for (const t of takeoffs.sort((a, b) => b.count - a.count)) {
+  console.log('── ' + t.type + ' (' + t.count + ') ──')
+  const qEntries = Object.entries(t.quantities).sort((a, b) => b[1].sum - a[1].sum)
+  if (qEntries.length === 0) {
+    console.log('  (no quantities defined)')
+  } else {
+    for (const [name, q] of qEntries) {
+      const avg = q.sum / q.count
+      console.log('  ' + name + ': total=' + q.sum.toFixed(2) + '  avg=' + avg.toFixed(2) + '  (from ' + q.count + ' entities)')
+    }
+  }
+  console.log('')
+}
+
+// ── Summary table ───────────────────────────────────────────────────────
+console.log('── Summary ──')
+console.log('Type                       | Count |    Area    |   Volume')
+console.log('---------------------------+-------+------------+-----------')
+for (const t of takeoffs.sort((a, b) => b.count - a.count)) {
+  // Find area and volume totals
+  let area = 0
+  let volume = 0
+  for (const [name, q] of Object.entries(t.quantities)) {
+    const lower = name.toLowerCase()
+    if (lower.includes('area') && !lower.includes('net')) area += q.sum
+    if (lower.includes('volume') && !lower.includes('net')) volume += q.sum
+  }
+  const typeStr = (t.type + '                           ').slice(0, 27)
+  const countStr = ('     ' + t.count).slice(-5)
+  const areaStr = area > 0 ? (area.toFixed(1) + ' m²') : '-'
+  const volStr = volume > 0 ? (volume.toFixed(2) + ' m³') : '-'
+  console.log(typeStr + '| ' + countStr + ' | ' + ('          ' + areaStr).slice(-10) + ' | ' + ('         ' + volStr).slice(-9))
+}
+
+// ── Export ───────────────────────────────────────────────────────────────
+// Build a flat entity list with quantities for CSV export
+const allElements = bim.query.byType(...ELEMENT_TYPES)
+if (allElements.length > 0) {
+  const qtyCols = Array.from(quantityColumns).sort()
+  bim.export.csv(allElements, {
+    columns: ['Name', 'Type', 'ObjectType', 'GlobalId', ...qtyCols],
+    filename: 'quantity-takeoff.csv'
+  })
+  console.log('')
+  console.log('Exported ' + allElements.length + ' elements (' + (4 + qtyCols.length) + ' columns) to quantity-takeoff.csv')
+}