@ifc-lite/viewer 1.7.0 → 1.9.0

package/src/lib/lens/adapter.ts

@@ -10,8 +10,14 @@
  * - Legacy single-model: uses offset = 0
  */
 
-import type { LensDataProvider, PropertySetInfo } from '@ifc-lite/lens';
+import type { LensDataProvider, PropertySetInfo, ClassificationInfo } from '@ifc-lite/lens';
 import type { IfcDataStore } from '@ifc-lite/parser';
+import {
+  extractEntityAttributesOnDemand,
+  extractQuantitiesOnDemand,
+  extractClassificationsOnDemand,
+  extractMaterialsOnDemand,
+} from '@ifc-lite/parser';
 import type { FederatedModel } from '@/store/types';
 
 interface ModelEntry {
@@ -111,6 +117,126 @@ export function createLensDataProvider(
       if (!psets) return [];
       return psets as PropertySetInfo[];
     },
+
+    getEntityAttribute(globalId: number, attrName: string): string | undefined {
+      const resolved = resolveGlobalId(globalId, entries);
+      if (!resolved) return undefined;
+      const store = resolved.entry.ifcDataStore;
+      const id = resolved.expressId;
+
+      // Fast path: columnar attributes stored during initial parse
+      switch (attrName) {
+        case 'Name':
+          return store.entities.getName(id) || undefined;
+        case 'Description': {
+          const desc = store.entities.getDescription?.(id);
+          if (desc) return desc;
+          break;
+        }
+        case 'ObjectType': {
+          const ot = store.entities.getObjectType?.(id);
+          if (ot) return ot;
+          break;
+        }
+        case 'Tag':
+          // Tag is not stored in columnar — always on-demand
+          break;
+        case 'GlobalId':
+          return store.entities.getGlobalId(id) || undefined;
+        case 'Type':
+          return store.entities.getTypeName?.(id) || undefined;
+      }
+
+      // Slow path: on-demand extraction from source buffer
+      if (store.source?.length > 0 && store.entityIndex) {
+        const attrs = extractEntityAttributesOnDemand(store, id);
+        switch (attrName) {
+          case 'Name': return attrs.name || undefined;
+          case 'Description': return attrs.description || undefined;
+          case 'ObjectType': return attrs.objectType || undefined;
+          case 'Tag': return attrs.tag || undefined;
+        }
+      }
+      return undefined;
+    },
+
+    getQuantityValue(
+      globalId: number,
+      qsetName: string,
+      quantName: string,
+    ): number | string | undefined {
+      const resolved = resolveGlobalId(globalId, entries);
+      if (!resolved) return undefined;
+      const store = resolved.entry.ifcDataStore;
+      const id = resolved.expressId;
+
+      // On-demand quantity extraction
+      if (store.onDemandQuantityMap && store.source?.length > 0) {
+        const qsets = extractQuantitiesOnDemand(store, id);
+        for (const qset of qsets) {
+          if (qset.name === qsetName) {
+            for (const q of qset.quantities) {
+              if (q.name === quantName) return q.value;
+            }
+          }
+        }
+        return undefined;
+      }
+
+      // Fallback: pre-built quantity tables
+      const qsets = store.quantities?.getForEntity?.(id);
+      if (!qsets) return undefined;
+      for (const qset of qsets) {
+        if (qset.name === qsetName) {
+          for (const q of qset.quantities) {
+            if (q.name === quantName) return q.value;
+          }
+        }
+      }
+      return undefined;
+    },
+
+    getClassifications(globalId: number): ClassificationInfo[] {
+      const resolved = resolveGlobalId(globalId, entries);
+      if (!resolved) return [];
+      const store = resolved.entry.ifcDataStore;
+      return extractClassificationsOnDemand(store, resolved.expressId);
+    },
+
+    getQuantitySets(globalId: number): ReadonlyArray<{
+      name: string;
+      quantities: ReadonlyArray<{ name: string }>;
+    }> {
+      const resolved = resolveGlobalId(globalId, entries);
+      if (!resolved) return [];
+      const store = resolved.entry.ifcDataStore;
+      const id = resolved.expressId;
+
+      // On-demand quantity extraction
+      if (store.onDemandQuantityMap && store.source?.length > 0) {
+        return extractQuantitiesOnDemand(store, id);
+      }
+
+      // Fallback: pre-built quantity tables
+      const qsets = store.quantities?.getForEntity?.(id);
+      if (!qsets) return [];
+      return qsets as ReadonlyArray<{ name: string; quantities: ReadonlyArray<{ name: string }> }>;
+    },
+
+    getMaterialName(globalId: number): string | undefined {
+      const resolved = resolveGlobalId(globalId, entries);
+      if (!resolved) return undefined;
+      const store = resolved.entry.ifcDataStore;
+      const info = extractMaterialsOnDemand(store, resolved.expressId);
+      if (!info) return undefined;
+      // Return the top-level material name, or first layer/constituent name
+      if (info.name) return info.name;
+      if (info.layers?.length) return info.layers[0].materialName;
+      if (info.constituents?.length) return info.constituents[0].materialName;
+      if (info.profiles?.length) return info.profiles[0].materialName;
+      if (info.materials?.length) return info.materials[0];
+      return undefined;
+    },
   };
 }
 

package/src/lib/lists/columnToAutoColor.ts

@@ -0,0 +1,33 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Maps a list ColumnDefinition to a lens AutoColorSpec.
+ * This bridges the lists feature (column-based data tables) with
+ * the lens feature (3D coloring) by converting column metadata
+ * into the auto-color specification used by the lens engine.
+ */
+
+import type { ColumnDefinition } from '@ifc-lite/lists';
+import type { AutoColorSpec } from '@ifc-lite/lens';
+
+/**
+ * Convert a list column definition to an auto-color spec.
+ *
+ * @param col - Column definition from a list configuration
+ * @returns AutoColorSpec for the lens engine
+ */
+export function columnToAutoColor(col: ColumnDefinition): AutoColorSpec {
+  switch (col.source) {
+    case 'attribute':
+      if (col.propertyName === 'Class') return { source: 'ifcType' };
+      return { source: 'attribute', propertyName: col.propertyName };
+    case 'property':
+      return { source: 'property', psetName: col.psetName, propertyName: col.propertyName };
+    case 'quantity':
+      return { source: 'quantity', psetName: col.psetName, propertyName: col.propertyName };
+    default:
+      return { source: 'ifcType' };
+  }
+}

package/src/lib/recent-files.ts

@@ -0,0 +1,122 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Track recently opened model files via localStorage + IndexedDB.
+ *
+ * localStorage: metadata (name, size, timestamp) — for palette display.
+ * IndexedDB:    actual file blobs — so recent files can be loaded instantly
+ *               without the user re-selecting them from the file picker.
+ *
+ * Shared between MainToolbar (writes) and CommandPalette (reads).
+ */
+
+const KEY = 'ifc-lite:recent-files';
+const DB_NAME = 'ifc-lite-file-cache';
+const DB_VERSION = 1;
+const STORE_NAME = 'files';
+const MAX_CACHED_FILES = 5;
+/** Max file size to cache (150 MB) — avoids filling IndexedDB quota */
+const MAX_CACHE_SIZE = 150 * 1024 * 1024;
+
+export interface RecentFileEntry {
+  name: string;
+  size: number;
+  timestamp: number;
+}
+
+// ── localStorage (metadata) ─────────────────────────────────────────────
+
+export function getRecentFiles(): RecentFileEntry[] {
+  try { return JSON.parse(localStorage.getItem(KEY) ?? '[]'); }
+  catch { return []; }
+}
+
+export function recordRecentFiles(files: { name: string; size: number }[]) {
+  try {
+    const names = new Set(files.map(f => f.name));
+    const existing = getRecentFiles().filter(f => !names.has(f.name));
+    const entries: RecentFileEntry[] = files.map(f => ({
+      name: f.name,
+      size: f.size,
+      timestamp: Date.now(),
+    }));
+    localStorage.setItem(KEY, JSON.stringify([...entries, ...existing].slice(0, 10)));
+  } catch { /* noop */ }
+}
+
+/** Format bytes into human-readable size */
+export function formatFileSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// ── IndexedDB (file blob cache) ─────────────────────────────────────────
+
+function openDB(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: 'name' });
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+/** Cache file blobs in IndexedDB for instant reload from palette. */
+export async function cacheFileBlobs(files: File[]): Promise<void> {
+  try {
+    const db = await openDB();
+    const tx = db.transaction(STORE_NAME, 'readwrite');
+    const store = tx.objectStore(STORE_NAME);
+
+    for (const file of files) {
+      if (file.size > MAX_CACHE_SIZE) continue; // skip oversized files
+      const blob = await file.arrayBuffer();
+      store.put({ name: file.name, blob, size: file.size, type: file.type, timestamp: Date.now() });
+    }
+
+    // Evict old entries beyond MAX_CACHED_FILES
+    const allReq = store.getAll();
+    allReq.onsuccess = () => {
+      const all = allReq.result as { name: string; timestamp: number }[];
+      if (all.length > MAX_CACHED_FILES) {
+        all.sort((a, b) => b.timestamp - a.timestamp);
+        for (let i = MAX_CACHED_FILES; i < all.length; i++) {
+          store.delete(all[i].name);
+        }
+      }
+    };
+
+    await new Promise<void>((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+    db.close();
+  } catch { /* IndexedDB unavailable — degrade gracefully */ }
+}
+
+/** Retrieve a cached file blob and reconstruct a File object. */
+export async function getCachedFile(name: string): Promise<File | null> {
+  try {
+    const db = await openDB();
+    const tx = db.transaction(STORE_NAME, 'readonly');
+    const store = tx.objectStore(STORE_NAME);
+    const req = store.get(name);
+    const result = await new Promise<{ name: string; blob: ArrayBuffer; size: number; type: string } | undefined>((resolve, reject) => {
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+    db.close();
+    if (!result) return null;
+    return new File([result.blob], result.name, { type: result.type || 'application/octet-stream' });
+  } catch {
+    return null;
+  }
+}

package/src/lib/scripts/persistence.ts

@@ -0,0 +1,132 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Persistence for user scripts via localStorage.
+ *
+ * Uses a versioned schema so future additions (tags, description, etc.)
+ * can be migrated without data loss.
+ */
+
+/** Current schema version */
+const SCHEMA_VERSION = 1;
+
+export interface SavedScript {
+  id: string;
+  name: string;
+  code: string;
+  createdAt: number;
+  updatedAt: number;
+  version: number;
+}
+
+/** Stored wrapper with schema version for migration */
+interface StoredScripts {
+  schemaVersion: number;
+  scripts: SavedScript[];
+}
+
+const STORAGE_KEY = 'ifc-lite-scripts';
+
+/** Maximum scripts allowed (prevents storage exhaustion) */
+const MAX_SCRIPTS = 500;
+
+/** Maximum code size per script in characters (~100KB) */
+const MAX_SCRIPT_SIZE = 100_000;
+
+export function loadSavedScripts(): SavedScript[] {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+
+    const parsed: unknown = JSON.parse(raw);
+
+    // Handle legacy format (bare array without schema version)
+    if (Array.isArray(parsed)) {
+      return migrateFromLegacy(parsed);
+    }
+
+    // Versioned format — validate structure
+    if (
+      typeof parsed === 'object' &&
+      parsed !== null &&
+      'schemaVersion' in parsed &&
+      'scripts' in parsed &&
+      Array.isArray((parsed as StoredScripts).scripts)
+    ) {
+      return (parsed as StoredScripts).scripts;
+    }
+
+    return [];
+  } catch {
+    return [];
+  }
+}
+
+/** Migrate from the original unversioned format — discards corrupted entries */
+function migrateFromLegacy(scripts: unknown[]): SavedScript[] {
+  const migrated: SavedScript[] = [];
+  for (const s of scripts) {
+    if (s === null || typeof s !== 'object') continue;
+    const script = s as Record<string, unknown>;
+
+    // Validate essential fields — discard garbage values from String()/Number() coercion
+    const id = typeof script.id === 'string' && script.id.length > 0 ? script.id : crypto.randomUUID();
+    const name = typeof script.name === 'string' && script.name.length > 0 ? script.name : 'Untitled';
+    const code = typeof script.code === 'string' ? script.code : '';
+    const createdAt = typeof script.createdAt === 'number' && isFinite(script.createdAt) ? script.createdAt : Date.now();
+    const updatedAt = typeof script.updatedAt === 'number' && isFinite(script.updatedAt) ? script.updatedAt : Date.now();
+
+    migrated.push({ id, name, code, createdAt, updatedAt, version: SCHEMA_VERSION });
+  }
+  // Save in new format
+  saveScripts(migrated);
+  return migrated;
+}
+
+export type SaveResult =
+  | { ok: true }
+  | { ok: false; reason: 'quota_exceeded' | 'serialization_error' | 'unknown'; message: string };
+
+export function saveScripts(scripts: SavedScript[]): SaveResult {
+  const stored: StoredScripts = {
+    schemaVersion: SCHEMA_VERSION,
+    scripts,
+  };
+
+  try {
+    const json = JSON.stringify(stored);
+    localStorage.setItem(STORAGE_KEY, json);
+    return { ok: true };
+  } catch (err: unknown) {
+    if (err instanceof DOMException && err.name === 'QuotaExceededError') {
+      console.warn('[Scripts] localStorage quota exceeded. Consider deleting unused scripts.');
+      return { ok: false, reason: 'quota_exceeded', message: 'Storage quota exceeded. Delete unused scripts to free space.' };
+    }
+    if (err instanceof TypeError) {
+      console.warn('[Scripts] Failed to serialize scripts:', err.message);
+      return { ok: false, reason: 'serialization_error', message: err.message };
+    }
+    console.warn('[Scripts] Failed to save scripts to localStorage');
+    return { ok: false, reason: 'unknown', message: String(err) };
+  }
+}
+
+/** Validate a script name — returns sanitized name or null if invalid */
+export function validateScriptName(name: string): string | null {
+  const trimmed = name.trim();
+  if (trimmed.length === 0) return null;
+  if (trimmed.length > 100) return trimmed.slice(0, 100);
+  return trimmed;
+}
+
+/** Check if adding another script is within limits */
+export function canCreateScript(currentCount: number): boolean {
+  return currentCount < MAX_SCRIPTS;
+}
+
+/** Check if script code is within size limits */
+export function isScriptWithinSizeLimit(code: string): boolean {
+  return code.length <= MAX_SCRIPT_SIZE;
+}

package/src/lib/scripts/templates/bim-globals.d.ts

@@ -0,0 +1,111 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * AUTO-GENERATED — do not edit by hand.
+ * Run: npx tsx scripts/generate-bim-globals.ts
+ *
+ * Type declarations for the sandbox `bim` global.
+ * Generated from NAMESPACE_SCHEMAS in bridge-schema.ts.
+ */
+
+// ── Entity types ────────────────────────────────────────────────────────
+
+interface BimEntity {
+  ref: { modelId: string; expressId: number };
+  name: string; Name: string;
+  type: string; Type: string;
+  globalId: string; GlobalId: string;
+  description: string; Description: string;
+  objectType: string; ObjectType: string;
+}
+
+interface BimPropertySet {
+  name: string;
+  properties: Array<{ name: string; value: string | number | boolean | null }>;
+}
+
+interface BimQuantitySet {
+  name: string;
+  quantities: Array<{ name: string; value: number | null }>;
+}
+
+interface BimModelInfo {
+  id: string;
+  name: string;
+  schemaVersion: string;
+  entityCount: number;
+  fileSize: number;
+}
+
+// ── Namespace declarations ──────────────────────────────────────────────
+
+declare const bim: {
+  /** Model operations */
+  model: {
+    /** List loaded models */
+    list(): BimModelInfo[];
+    /** Get active model */
+    active(): BimModelInfo | null;
+    /** Get active model ID */
+    activeId(): string | null;
+  };
+  /** Query entities */
+  query: {
+    /** Get all entities */
+    all(): BimEntity[];
+    /** Filter by IFC type e.g. 'IfcWall' */
+    byType(...types: string[]): BimEntity[];
+    /** Get entity by model ID and express ID */
+    entity(modelId: string, expressId: number): BimEntity | null;
+    /** Get all IfcPropertySet data for an entity */
+    properties(entity: BimEntity): BimPropertySet[];
+    /** Get all IfcElementQuantity data for an entity */
+    quantities(entity: BimEntity): BimQuantitySet[];
+  };
+  /** Viewer control */
+  viewer: {
+    /** Colorize entities e.g. '#ff0000' */
+    colorize(entities: BimEntity[], color: string): void;
+    /** Batch colorize with [{entities, color}] */
+    colorizeAll(batches: Array<{ entities: BimEntity[]; color: string }>): void;
+    /** Hide entities */
+    hide(entities: BimEntity[]): void;
+    /** Show entities */
+    show(entities: BimEntity[]): void;
+    /** Isolate entities */
+    isolate(entities: BimEntity[]): void;
+    /** Select entities */
+    select(entities: BimEntity[]): void;
+    /** Fly camera to entities */
+    flyTo(entities: BimEntity[]): void;
+    /** Reset all colors */
+    resetColors(): void;
+    /** Reset all visibility */
+    resetVisibility(): void;
+  };
+  /** Property editing */
+  mutate: {
+    /** Set a property value */
+    setProperty(entity: unknown, psetName: string, propName: string, value: unknown): void;
+    /** Delete a property */
+    deleteProperty(entity: unknown, psetName: string, propName: string): void;
+    /** Undo last mutation */
+    undo(modelId: string): void;
+    /** Redo undone mutation */
+    redo(modelId: string): void;
+  };
+  /** Lens visualization */
+  lens: {
+    /** Get built-in lens presets */
+    presets(): unknown[];
+  };
+  /** Data export */
+  export: {
+    /** Export entities to CSV string */
+    csv(entities: BimEntity[], options: { columns: string[]; filename?: string; separator?: string }): string;
+    /** Export entities to JSON array */
+    json(entities: BimEntity[], columns: string[]): Record<string, unknown>[];
+  };
+};

package/src/lib/scripts/templates/data-quality-audit.ts

@@ -0,0 +1,149 @@
+export {} // module boundary (stripped by transpiler)
+
+// ── Data Quality Audit ──────────────────────────────────────────────────
+// Stakeholder: BIM Manager / QA
+//
+// Scans every entity in the model for data completeness issues that would
+// take hours to find by clicking through the UI. Produces a scorecard,
+// color-codes the 3D view by quality level, and exports an issues CSV.
+// ─────────────────────────────────────────────────────────────────────────
+
+bim.viewer.resetColors()
+const all = bim.query.all()
+if (all.length === 0) { console.error('No entities loaded'); throw new Error('empty model') }
+
+// ── 1. Check every entity for missing attributes ────────────────────────
+interface Issue { entity: BimEntity; field: string }
+const issues: Issue[] = []
+const scores: Record<string, { entity: BimEntity; score: number }> = {}
+
+// Track property coverage per type
+const typePsetCoverage: Record<string, { total: number; withPsets: number }> = {}
+
+for (const e of all) {
+  let score = 0
+  const maxScore = 5 // Name, Description, ObjectType, has properties, has quantities
+
+  if (e.Name && e.Name !== '') score++
+  else issues.push({ entity: e, field: 'Name' })
+
+  if (e.Description && e.Description !== '') score++
+  else issues.push({ entity: e, field: 'Description' })
+
+  if (e.ObjectType && e.ObjectType !== '') score++
+  else issues.push({ entity: e, field: 'ObjectType' })
+
+  const psets = bim.query.properties(e)
+  if (psets.length > 0) score++
+  else issues.push({ entity: e, field: 'PropertySets' })
+
+  const qsets = bim.query.quantities(e)
+  if (qsets.length > 0) score++
+  else issues.push({ entity: e, field: 'Quantities' })
+
+  scores[e.GlobalId] = { entity: e, score }
+
+  // Track pset coverage per type
+  if (!typePsetCoverage[e.Type]) typePsetCoverage[e.Type] = { total: 0, withPsets: 0 }
+  typePsetCoverage[e.Type].total++
+  if (psets.length > 0) typePsetCoverage[e.Type].withPsets++
+}
+
+// ── 2. Classify entities by quality tier ────────────────────────────────
+const tiers = { complete: [] as BimEntity[], good: [] as BimEntity[], partial: [] as BimEntity[], poor: [] as BimEntity[] }
+for (const { entity, score } of Object.values(scores)) {
+  if (score === 5) tiers.complete.push(entity)
+  else if (score >= 4) tiers.good.push(entity)
+  else if (score >= 2) tiers.partial.push(entity)
+  else tiers.poor.push(entity)
+}
+
+// ── 3. Color-code by quality ────────────────────────────────────────────
+const batches: Array<{ entities: BimEntity[]; color: string }> = []
+if (tiers.complete.length > 0) batches.push({ entities: tiers.complete, color: '#27ae60' }) // green
+if (tiers.good.length > 0) batches.push({ entities: tiers.good, color: '#f1c40f' })    // yellow
+if (tiers.partial.length > 0) batches.push({ entities: tiers.partial, color: '#e67e22' }) // orange
+if (tiers.poor.length > 0) batches.push({ entities: tiers.poor, color: '#e74c3c' })    // red
+if (batches.length > 0) bim.viewer.colorizeAll(batches)
+
+// ── 4. Report ───────────────────────────────────────────────────────────
+const overallScore = ((tiers.complete.length + tiers.good.length * 0.8 + tiers.partial.length * 0.4) / all.length * 100)
+console.log('═══════════════════════════════════════')
+console.log('  DATA QUALITY AUDIT')
+console.log('═══════════════════════════════════════')
+console.log('')
+console.log('Overall score: ' + overallScore.toFixed(1) + '% (' + all.length + ' entities)')
+console.log('')
+console.log('  Complete (5/5): ' + tiers.complete.length + '  ● green')
+console.log('  Good     (4/5): ' + tiers.good.length + '  ● yellow')
+console.log('  Partial  (2-3): ' + tiers.partial.length + '  ● orange')
+console.log('  Poor     (0-1): ' + tiers.poor.length + '  ● red')
+
+// ── 5. Issue breakdown by field ─────────────────────────────────────────
+const issuesByField: Record<string, number> = {}
+for (const issue of issues) {
+  issuesByField[issue.field] = (issuesByField[issue.field] || 0) + 1
+}
+console.log('')
+console.log('── Missing Data Breakdown ──')
+for (const [field, count] of Object.entries(issuesByField).sort((a, b) => b[1] - a[1])) {
+  const pct = (count / all.length * 100).toFixed(1)
+  console.log('  ' + field + ': ' + count + ' entities (' + pct + '% missing)')
+}
+
+// ── 6. Property coverage per type ───────────────────────────────────────
+console.log('')
+console.log('── Property Coverage by Type ──')
+const coverageSorted = Object.entries(typePsetCoverage)
+  .sort((a, b) => b[1].total - a[1].total)
+  .slice(0, 15)
+for (const [type, cov] of coverageSorted) {
+  const pct = (cov.withPsets / cov.total * 100).toFixed(0)
+  const bar = '█'.repeat(Math.round(cov.withPsets / cov.total * 20))
+  console.log('  ' + type + ': ' + bar + ' ' + pct + '% (' + cov.withPsets + '/' + cov.total + ')')
+}
+
+// ── 7. Worst offenders (first 10 entities with score 0-1) ──────────────
+if (tiers.poor.length > 0) {
+  console.log('')
+  console.log('── Worst Offenders (score 0-1) ──')
+  for (const e of tiers.poor.slice(0, 10)) {
+    console.log('  ' + (e.Name || '<no name>') + ' [' + e.Type + '] GlobalId=' + e.GlobalId)
+  }
+  if (tiers.poor.length > 10) {
+    console.log('  ... and ' + (tiers.poor.length - 10) + ' more')
+  }
+}
+
+// ── 8. Export all entities with discovered property/quantity data ────────
+// Discover common property columns from a sample
+const sampleForDiscovery = all.slice(0, 200)
+const discoveredPropPaths = new Set<string>()
+const discoveredQtyPaths = new Set<string>()
+for (const e of sampleForDiscovery) {
+  const psets = bim.query.properties(e)
+  for (const pset of psets) {
+    for (const p of pset.properties) {
+      if (p.value !== null && p.value !== '') {
+        discoveredPropPaths.add(pset.name + '.' + p.name)
+      }
+    }
+  }
+  const qsets = bim.query.quantities(e)
+  for (const qset of qsets) {
+    for (const q of qset.quantities) {
+      if (q.value !== null && q.value !== 0) {
+        discoveredQtyPaths.add(qset.name + '.' + q.name)
+      }
+    }
+  }
+}
+// Cap columns to keep CSV manageable
+const auditPropCols = Array.from(discoveredPropPaths).sort().slice(0, 20)
+const auditQtyCols = Array.from(discoveredQtyPaths).sort().slice(0, 10)
+bim.export.csv(all, {
+  columns: ['Name', 'Type', 'GlobalId', 'Description', 'ObjectType', ...auditPropCols, ...auditQtyCols],
+  filename: 'data-quality-audit.csv'
+})
+console.log('')
+console.log('Exported ' + all.length + ' entities (' + (5 + auditPropCols.length + auditQtyCols.length) + ' columns) to data-quality-audit.csv')