@ifc-lite/viewer 1.6.0 → 1.7.0

package/src/lib/ifc4-qto-definitions.ts

@@ -0,0 +1,315 @@
+/* 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/. */
+
+/**
+ * IFC4 Quantity Set Definitions (Qto_)
+ *
+ * Maps IFC entity types to their standard base quantities
+ * according to the IFC4 standard (ISO 16739-1:2018).
+ *
+ * Used by the quantity editor to validate and suggest additions.
+ */
+
+import { QuantityType } from '@ifc-lite/data';
+
+export interface QtoQuantityDef {
+  name: string;
+  type: QuantityType;
+  description: string;
+  unit: string;
+}
+
+export interface QtoDefinition {
+  name: string;
+  description: string;
+  applicableTypes: string[];
+  quantities: QtoQuantityDef[];
+}
+
+// ============================================================================
+// IFC4 Standard Quantity Set Definitions
+// ============================================================================
+
+const QTO_DEFINITIONS: QtoDefinition[] = [
+  // ---------------------------------------------------------------------------
+  // Wall Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_WallBaseQuantities',
+    description: 'Base quantities for walls',
+    applicableTypes: ['IfcWall', 'IfcWallStandardCase', 'IfcCurtainWall'],
+    quantities: [
+      { name: 'Length', type: QuantityType.Length, description: 'Length along the wall path', unit: 'm' },
+      { name: 'Width', type: QuantityType.Length, description: 'Wall thickness', unit: 'm' },
+      { name: 'Height', type: QuantityType.Length, description: 'Wall height', unit: 'm' },
+      { name: 'GrossFootprintArea', type: QuantityType.Area, description: 'Gross footprint area including openings', unit: 'm²' },
+      { name: 'NetFootprintArea', type: QuantityType.Area, description: 'Net footprint area excluding openings', unit: 'm²' },
+      { name: 'GrossSideArea', type: QuantityType.Area, description: 'Gross side area including openings', unit: 'm²' },
+      { name: 'NetSideArea', type: QuantityType.Area, description: 'Net side area excluding openings', unit: 'm²' },
+      { name: 'GrossVolume', type: QuantityType.Volume, description: 'Gross volume including openings', unit: 'm³' },
+      { name: 'NetVolume', type: QuantityType.Volume, description: 'Net volume excluding openings', unit: 'm³' },
+      { name: 'GrossWeight', type: QuantityType.Weight, description: 'Gross weight', unit: 'kg' },
+      { name: 'NetWeight', type: QuantityType.Weight, description: 'Net weight', unit: 'kg' },
+    ],
+  },
+
+  // ---------------------------------------------------------------------------
+  // Slab Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_SlabBaseQuantities',
+    description: 'Base quantities for slabs',
+    applicableTypes: ['IfcSlab'],
+    quantities: [
+      { name: 'Width', type: QuantityType.Length, description: 'Slab thickness', unit: 'm' },
+      { name: 'Perimeter', type: QuantityType.Length, description: 'Slab perimeter', unit: 'm' },
+      { name: 'GrossArea', type: QuantityType.Area, description: 'Gross area including openings', unit: 'm²' },
+      { name: 'NetArea', type: QuantityType.Area, description: 'Net area excluding openings', unit: 'm²' },
+      { name: 'GrossVolume', type: QuantityType.Volume, description: 'Gross volume including openings', unit: 'm³' },
+      { name: 'NetVolume', type: QuantityType.Volume, description: 'Net volume excluding openings', unit: 'm³' },
+      { name: 'GrossWeight', type: QuantityType.Weight, description: 'Gross weight', unit: 'kg' },
+      { name: 'NetWeight', type: QuantityType.Weight, description: 'Net weight', unit: 'kg' },
+    ],
+  },
+
+  // ---------------------------------------------------------------------------
+  // Door Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_DoorBaseQuantities',
+    description: 'Base quantities for doors',
+    applicableTypes: ['IfcDoor'],
+    quantities: [
+      { name: 'Width', type: QuantityType.Length, description: 'Overall width', unit: 'm' },
+      { name: 'Height', type: QuantityType.Length, description: 'Overall height', unit: 'm' },
+      { name: 'Perimeter', type: QuantityType.Length, description: 'Perimeter of door opening', unit: 'm' },
+      { name: 'Area', type: QuantityType.Area, description: 'Total area of door opening', unit: 'm²' },
+    ],
+  },
+
+  // ---------------------------------------------------------------------------
+  // Window Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_WindowBaseQuantities',
+    description: 'Base quantities for windows',
+    applicableTypes: ['IfcWindow'],
+    quantities: [
+      { name: 'Width', type: QuantityType.Length, description: 'Overall width', unit: 'm' },
+      { name: 'Height', type: QuantityType.Length, description: 'Overall height', unit: 'm' },
+      { name: 'Perimeter', type: QuantityType.Length, description: 'Perimeter of window opening', unit: 'm' },
+      { name: 'Area', type: QuantityType.Area, description: 'Total area of window opening', unit: 'm²' },
+    ],
+  },
+
+  // ---------------------------------------------------------------------------
+  // Column Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_ColumnBaseQuantities',
+    description: 'Base quantities for columns',
+    applicableTypes: ['IfcColumn'],
+    quantities: [
+      { name: 'Length', type: QuantityType.Length, description: 'Column length (typically height)', unit: 'm' },
+      { name: 'CrossSectionArea', type: QuantityType.Area, description: 'Cross section area', unit: 'm²' },
+      { name: 'OuterSurfaceArea', type: QuantityType.Area, description: 'Outer surface area', unit: 'm²' },
+      { name: 'GrossVolume', type: QuantityType.Volume, description: 'Gross volume', unit: 'm³' },
+      { name: 'NetVolume', type: QuantityType.Volume, description: 'Net volume', unit: 'm³' },
+      { name: 'GrossWeight', type: QuantityType.Weight, description: 'Gross weight', unit: 'kg' },
+      { name: 'NetWeight', type: QuantityType.Weight, description: 'Net weight', unit: 'kg' },
+    ],
+  },
+
+  // ---------------------------------------------------------------------------
+  // Beam Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_BeamBaseQuantities',
+    description: 'Base quantities for beams',
+    applicableTypes: ['IfcBeam'],
+    quantities: [
+      { name: 'Length', type: QuantityType.Length, description: 'Beam length', unit: 'm' },
+      { name: 'CrossSectionArea', type: QuantityType.Area, description: 'Cross section area', unit: 'm²' },
+      { name: 'OuterSurfaceArea', type: QuantityType.Area, description: 'Outer surface area', unit: 'm²' },
+      { name: 'GrossVolume', type: QuantityType.Volume, description: 'Gross volume', unit: 'm³' },
+      { name: 'NetVolume', type: QuantityType.Volume, description: 'Net volume', unit: 'm³' },
+      { name: 'GrossWeight', type: QuantityType.Weight, description: 'Gross weight', unit: 'kg' },
+      { name: 'NetWeight', type: QuantityType.Weight, description: 'Net weight', unit: 'kg' },
+    ],
+  },
+
+  // ---------------------------------------------------------------------------
+  // Stair Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_StairFlightBaseQuantities',
+    description: 'Base quantities for stair flights',
+    applicableTypes: ['IfcStair'],
+    quantities: [
+      { name: 'Length', type: QuantityType.Length, description: 'Stair flight length', unit: 'm' },
+      { name: 'GrossVolume', type: QuantityType.Volume, description: 'Gross volume', unit: 'm³' },
+      { name: 'NetVolume', type: QuantityType.Volume, description: 'Net volume', unit: 'm³' },
+    ],
+  },
+
+  // ---------------------------------------------------------------------------
+  // Ramp Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_RampFlightBaseQuantities',
+    description: 'Base quantities for ramp flights',
+    applicableTypes: ['IfcRamp'],
+    quantities: [
+      { name: 'Length', type: QuantityType.Length, description: 'Ramp flight length', unit: 'm' },
+      { name: 'Width', type: QuantityType.Length, description: 'Ramp width', unit: 'm' },
+      { name: 'GrossArea', type: QuantityType.Area, description: 'Gross area', unit: 'm²' },
+      { name: 'NetArea', type: QuantityType.Area, description: 'Net area', unit: 'm²' },
+      { name: 'GrossVolume', type: QuantityType.Volume, description: 'Gross volume', unit: 'm³' },
+      { name: 'NetVolume', type: QuantityType.Volume, description: 'Net volume', unit: 'm³' },
+    ],
+  },
+
+  // ---------------------------------------------------------------------------
+  // Roof Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_RoofBaseQuantities',
+    description: 'Base quantities for roofs',
+    applicableTypes: ['IfcRoof'],
+    quantities: [
+      { name: 'GrossArea', type: QuantityType.Area, description: 'Total gross area of the roof', unit: 'm²' },
+      { name: 'NetArea', type: QuantityType.Area, description: 'Net area excluding openings', unit: 'm²' },
+      { name: 'ProjectedArea', type: QuantityType.Area, description: 'Projected horizontal area', unit: 'm²' },
+    ],
+  },
+
+  // ---------------------------------------------------------------------------
+  // Covering Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_CoveringBaseQuantities',
+    description: 'Base quantities for coverings',
+    applicableTypes: ['IfcCovering'],
+    quantities: [
+      { name: 'Width', type: QuantityType.Length, description: 'Covering thickness', unit: 'm' },
+      { name: 'GrossArea', type: QuantityType.Area, description: 'Gross area', unit: 'm²' },
+      { name: 'NetArea', type: QuantityType.Area, description: 'Net area', unit: 'm²' },
+    ],
+  },
+
+  // ---------------------------------------------------------------------------
+  // Space Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_SpaceBaseQuantities',
+    description: 'Base quantities for spaces',
+    applicableTypes: ['IfcSpace'],
+    quantities: [
+      { name: 'Height', type: QuantityType.Length, description: 'Net height of the space', unit: 'm' },
+      { name: 'FinishCeilingHeight', type: QuantityType.Length, description: 'Height from floor to ceiling finish', unit: 'm' },
+      { name: 'FinishFloorHeight', type: QuantityType.Length, description: 'Floor finish height', unit: 'm' },
+      { name: 'GrossPerimeter', type: QuantityType.Length, description: 'Gross floor perimeter', unit: 'm' },
+      { name: 'NetPerimeter', type: QuantityType.Length, description: 'Net floor perimeter', unit: 'm' },
+      { name: 'GrossFloorArea', type: QuantityType.Area, description: 'Gross floor area', unit: 'm²' },
+      { name: 'NetFloorArea', type: QuantityType.Area, description: 'Net floor area', unit: 'm²' },
+      { name: 'GrossWallArea', type: QuantityType.Area, description: 'Gross wall area', unit: 'm²' },
+      { name: 'NetWallArea', type: QuantityType.Area, description: 'Net wall area', unit: 'm²' },
+      { name: 'GrossCeilingArea', type: QuantityType.Area, description: 'Gross ceiling area', unit: 'm²' },
+      { name: 'NetCeilingArea', type: QuantityType.Area, description: 'Net ceiling area', unit: 'm²' },
+      { name: 'GrossVolume', type: QuantityType.Volume, description: 'Gross volume', unit: 'm³' },
+      { name: 'NetVolume', type: QuantityType.Volume, description: 'Net volume', unit: 'm³' },
+    ],
+  },
+
+  // ---------------------------------------------------------------------------
+  // Building Storey Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_BuildingStoreyBaseQuantities',
+    description: 'Base quantities for building storeys',
+    applicableTypes: ['IfcBuildingStorey'],
+    quantities: [
+      { name: 'GrossHeight', type: QuantityType.Length, description: 'Gross height (floor-to-floor)', unit: 'm' },
+      { name: 'NetHeight', type: QuantityType.Length, description: 'Net height (floor-to-ceiling)', unit: 'm' },
+      { name: 'GrossFloorArea', type: QuantityType.Area, description: 'Gross floor area', unit: 'm²' },
+      { name: 'NetFloorArea', type: QuantityType.Area, description: 'Net floor area', unit: 'm²' },
+      { name: 'GrossVolume', type: QuantityType.Volume, description: 'Gross volume', unit: 'm³' },
+      { name: 'NetVolume', type: QuantityType.Volume, description: 'Net volume', unit: 'm³' },
+    ],
+  },
+
+  // ---------------------------------------------------------------------------
+  // Railing Base Quantities
+  // ---------------------------------------------------------------------------
+  {
+    name: 'Qto_RailingBaseQuantities',
+    description: 'Base quantities for railings',
+    applicableTypes: ['IfcRailing'],
+    quantities: [
+      { name: 'Length', type: QuantityType.Length, description: 'Railing length', unit: 'm' },
+    ],
+  },
+];
+
+// ============================================================================
+// Lookup Functions
+// ============================================================================
+
+// Pre-computed uppercase -> PascalCase lookup map for all known types
+const KNOWN_TYPE_MAP = new Map<string, string>();
+for (const qto of QTO_DEFINITIONS) {
+  for (const t of qto.applicableTypes) {
+    KNOWN_TYPE_MAP.set(t.toUpperCase(), t);
+  }
+}
+
+function normalizeTypeName(type: string): string {
+  if (type.startsWith('Ifc')) return type;
+  const upper = type.toUpperCase();
+  if (!upper.startsWith('IFC')) return type;
+  const known = KNOWN_TYPE_MAP.get(upper);
+  if (known) return known;
+  const rest = type.slice(3).toLowerCase();
+  return 'Ifc' + rest.charAt(0).toUpperCase() + rest.slice(1);
+}
+
+/**
+ * Get all valid quantity set definitions for a given IFC entity type.
+ */
+export function getQtoDefinitionsForType(entityType: string): QtoDefinition[] {
+  const normalized = normalizeTypeName(entityType);
+  return QTO_DEFINITIONS.filter(qto =>
+    qto.applicableTypes.some(t => t === normalized)
+  );
+}
+
+/**
+ * Get a specific quantity set definition by name.
+ */
+export function getQtoDefinition(qtoName: string): QtoDefinition | undefined {
+  return QTO_DEFINITIONS.find(q => q.name === qtoName);
+}
+
+/**
+ * Get the quantity definitions for a specific quantity set.
+ */
+export function getQuantitiesForQto(qtoName: string): QtoQuantityDef[] {
+  const qto = QTO_DEFINITIONS.find(q => q.name === qtoName);
+  return qto ? qto.quantities : [];
+}
+
+/**
+ * Get the display unit suffix for a quantity type.
+ */
+export function getQuantityUnit(type: QuantityType): string {
+  switch (type) {
+    case QuantityType.Length: return 'm';
+    case QuantityType.Area: return 'm²';
+    case QuantityType.Volume: return 'm³';
+    case QuantityType.Weight: return 'kg';
+    case QuantityType.Count: return '';
+    case QuantityType.Time: return 's';
+    default: return '';
+  }
+}

package/src/lib/lens/adapter.ts

@@ -0,0 +1,138 @@
+/* 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/. */
+
+/**
+ * Creates a {@link LensDataProvider} from the viewer's data sources.
+ *
+ * Bridges the abstract provider interface to IfcDataStore + federation:
+ * - Multi-model: iterates all models, translates global IDs
+ * - Legacy single-model: uses offset = 0
+ */
+
+import type { LensDataProvider, PropertySetInfo } from '@ifc-lite/lens';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { FederatedModel } from '@/store/types';
+
+interface ModelEntry {
+  id: string;
+  ifcDataStore: IfcDataStore;
+  idOffset: number;
+  maxExpressId: number;
+}
+
+/** Scan entity array to find the actual maximum expressId */
+function computeMaxExpressId(dataStore: IfcDataStore): number {
+  const entities = dataStore.entities;
+  if (!entities || entities.count === 0) return 0;
+  let max = 0;
+  for (let i = 0; i < entities.count; i++) {
+    if (entities.expressId[i] > max) max = entities.expressId[i];
+  }
+  return max;
+}
+
+/**
+ * Create a LensDataProvider for the viewer's federated models.
+ *
+ * @param models - Loaded federated models (may be empty in legacy mode)
+ * @param legacyDataStore - Single-model data store (fallback)
+ */
+export function createLensDataProvider(
+  models: Map<string, FederatedModel>,
+  legacyDataStore: IfcDataStore | null,
+): LensDataProvider {
+  // Build a flat array for fast iteration
+  const entries: ModelEntry[] = [];
+  if (models.size > 0) {
+    for (const [, model] of models) {
+      if (model.ifcDataStore) {
+        entries.push({
+          id: model.id,
+          ifcDataStore: model.ifcDataStore,
+          idOffset: model.idOffset ?? 0,
+          maxExpressId: model.maxExpressId ?? 0,
+        });
+      }
+    }
+  } else if (legacyDataStore) {
+    entries.push({
+      id: 'legacy',
+      ifcDataStore: legacyDataStore,
+      idOffset: 0,
+      maxExpressId: computeMaxExpressId(legacyDataStore),
+    });
+  }
+
+  return {
+    getEntityCount(): number {
+      let count = 0;
+      for (const entry of entries) {
+        count += entry.ifcDataStore.entities?.count ?? 0;
+      }
+      return count;
+    },
+
+    forEachEntity(callback: (globalId: number, modelId: string) => void): void {
+      for (const entry of entries) {
+        const entities = entry.ifcDataStore.entities;
+        if (!entities) continue;
+        for (let i = 0; i < entities.count; i++) {
+          const expressId = entities.expressId[i];
+          callback(expressId + entry.idOffset, entry.id);
+        }
+      }
+    },
+
+    getEntityType(globalId: number): string | undefined {
+      const resolved = resolveGlobalId(globalId, entries);
+      if (!resolved) return undefined;
+      return resolved.entry.ifcDataStore.entities?.getTypeName?.(resolved.expressId);
+    },
+
+    getPropertyValue(
+      globalId: number,
+      propertySetName: string,
+      propertyName: string,
+    ): unknown {
+      const resolved = resolveGlobalId(globalId, entries);
+      if (!resolved) return undefined;
+      return resolved.entry.ifcDataStore.properties?.getPropertyValue?.(
+        resolved.expressId,
+        propertySetName,
+        propertyName,
+      );
+    },
+
+    getPropertySets(globalId: number): PropertySetInfo[] {
+      const resolved = resolveGlobalId(globalId, entries);
+      if (!resolved) return [];
+      const psets = resolved.entry.ifcDataStore.properties?.getForEntity?.(resolved.expressId);
+      if (!psets) return [];
+      return psets as PropertySetInfo[];
+    },
+  };
+}
+
+/**
+ * Resolve a global ID to (entry, local expressId).
+ * O(m) where m = model count (typically 1–5).
+ * Reuses a single result object to avoid per-call allocation during
+ * hot-loop lens evaluation (100k+ calls).
+ */
+const _resolved = { entry: null as unknown as ModelEntry, expressId: 0 };
+
+function resolveGlobalId(
+  globalId: number,
+  entries: ModelEntry[],
+): typeof _resolved | null {
+  for (const entry of entries) {
+    const localId = globalId - entry.idOffset;
+    if (localId >= 0 && localId <= entry.maxExpressId) {
+      _resolved.entry = entry;
+      _resolved.expressId = localId;
+      return _resolved;
+    }
+  }
+  return null;
+}

package/src/lib/lens/index.ts

@@ -0,0 +1,5 @@
+/* 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/. */
+
+export { createLensDataProvider } from './adapter.js';

package/src/lib/lists/adapter.ts

@@ -0,0 +1,69 @@
+/* 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/. */
+
+/**
+ * Adapter that bridges IfcDataStore (parser output) to the
+ * ListDataProvider interface used by @ifc-lite/lists.
+ *
+ * Handles on-demand property/quantity extraction via WASM when needed.
+ * Also handles on-demand attribute extraction for Description, ObjectType,
+ * and Tag which are not stored during the fast initial parse.
+ */
+
+import type { IfcDataStore } from '@ifc-lite/parser';
+import { extractPropertiesOnDemand, extractQuantitiesOnDemand, extractEntityAttributesOnDemand } from '@ifc-lite/parser';
+import type { PropertySet, QuantitySet } from '@ifc-lite/data';
+import type { ListDataProvider } from '@ifc-lite/lists';
+
+/**
+ * Create a ListDataProvider backed by an IfcDataStore.
+ * The provider handles on-demand WASM extraction transparently.
+ */
+export function createListDataProvider(store: IfcDataStore): ListDataProvider {
+  // Cache for on-demand attribute extraction (description, objectType, tag)
+  // These are not stored during initial parse to keep load times fast,
+  // but are needed for list display. Cache avoids re-parsing per column.
+  const attrCache = new Map<number, { description: string; objectType: string; tag: string }>();
+
+  function getOnDemandAttrs(id: number): { description: string; objectType: string; tag: string } {
+    const cached = attrCache.get(id);
+    if (cached) return cached;
+
+    if (store.source?.length > 0 && store.entityIndex) {
+      const attrs = extractEntityAttributesOnDemand(store, id);
+      const result = { description: attrs.description, objectType: attrs.objectType, tag: attrs.tag };
+      attrCache.set(id, result);
+      return result;
+    }
+
+    const empty = { description: '', objectType: '', tag: '' };
+    attrCache.set(id, empty);
+    return empty;
+  }
+
+  return {
+    getEntitiesByType: (type) => store.entities.getByType(type),
+
+    getEntityName: (id) => store.entities.getName(id),
+    getEntityGlobalId: (id) => store.entities.getGlobalId(id),
+    getEntityDescription: (id) => store.entities.getDescription(id) || getOnDemandAttrs(id).description,
+    getEntityObjectType: (id) => store.entities.getObjectType(id) || getOnDemandAttrs(id).objectType,
+    getEntityTag: (id) => getOnDemandAttrs(id).tag,
+    getEntityTypeName: (id) => store.entities.getTypeName(id),
+
+    getPropertySets(entityId: number): PropertySet[] {
+      if (store.onDemandPropertyMap && store.source?.length > 0) {
+        return extractPropertiesOnDemand(store, entityId) as PropertySet[];
+      }
+      return store.properties?.getForEntity(entityId) ?? [];
+    },
+
+    getQuantitySets(entityId: number): QuantitySet[] {
+      if (store.onDemandQuantityMap && store.source?.length > 0) {
+        return extractQuantitiesOnDemand(store, entityId) as QuantitySet[];
+      }
+      return store.quantities?.getForEntity(entityId) ?? [];
+    },
+  };
+}

package/src/lib/lists/index.ts

@@ -0,0 +1,28 @@
+/* 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/. */
+
+// Re-export from the @ifc-lite/lists package for convenient viewer imports
+export type {
+  ListDataProvider,
+  ListDefinition,
+  ListResult,
+  ListRow,
+  CellValue,
+  ColumnDefinition,
+  PropertyCondition,
+  ConditionOperator,
+  DiscoveredColumns,
+  EntityAttribute,
+} from '@ifc-lite/lists';
+export {
+  ENTITY_ATTRIBUTES,
+  executeList,
+  listResultToCSV,
+  discoverColumns,
+  LIST_PRESETS,
+} from '@ifc-lite/lists';
+
+// Viewer-specific: persistence (browser APIs) and adapter
+export { loadListDefinitions, saveListDefinitions, exportListDefinition, importListDefinition } from './persistence.js';
+export { createListDataProvider } from './adapter.js';

package/src/lib/lists/persistence.ts

@@ -0,0 +1,64 @@
+/* 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 list definitions via localStorage
+ */
+
+import type { ListDefinition } from '@ifc-lite/lists';
+
+const STORAGE_KEY = 'ifc-lite-lists';
+
+export function loadListDefinitions(): ListDefinition[] {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+    return JSON.parse(raw) as ListDefinition[];
+  } catch {
+    return [];
+  }
+}
+
+export function saveListDefinitions(definitions: ListDefinition[]): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(definitions));
+  } catch {
+    console.warn('[Lists] Failed to save list definitions to localStorage');
+  }
+}
+
+export function exportListDefinition(definition: ListDefinition): void {
+  const json = JSON.stringify(definition, null, 2);
+  const blob = new Blob([json], { type: 'application/json' });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = `${definition.name.replace(/[^a-zA-Z0-9-_]/g, '_')}.list.json`;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+export function importListDefinition(file: File): Promise<ListDefinition> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      try {
+        const def = JSON.parse(reader.result as string) as ListDefinition;
+        if (!def.id || !def.name || !def.entityTypes || !def.columns) {
+          reject(new Error('Invalid list definition file'));
+          return;
+        }
+        // Generate a new ID to avoid collisions
+        def.id = crypto.randomUUID();
+        def.createdAt = Date.now();
+        def.updatedAt = Date.now();
+        resolve(def);
+      } catch {
+        reject(new Error('Failed to parse list definition file'));
+      }
+    };
+    reader.onerror = () => reject(new Error('Failed to read file'));
+    reader.readAsText(file);
+  });
+}

package/src/services/fs-cache.ts

@@ -66,7 +66,7 @@ export async function getCached(key: string): Promise<ArrayBuffer | null> {
 
     const data = await fs.readFile(cachePath);
     // Slice to actual data range - Uint8Array.buffer may contain extra bytes
-    const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    const buffer = (data.buffer as ArrayBuffer).slice(data.byteOffset, data.byteOffset + data.byteLength);
 
     console.log(`[FS Cache] Cache hit for key ${key} (${(buffer.byteLength / 1024 / 1024).toFixed(2)}MB)`);
     return buffer;

package/src/services/tauri-modules.d.ts

@@ -0,0 +1,25 @@
+/* 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/. */
+
+/**
+ * Ambient type declarations for Tauri-only modules.
+ * These packages are only available at runtime in desktop (Tauri) builds
+ * and are not installed in the web viewer's node_modules.
+ */
+
+declare module '@tauri-apps/plugin-fs' {
+  export function mkdir(path: string, options?: { recursive?: boolean }): Promise<void>;
+  export function writeFile(path: string, data: Uint8Array): Promise<void>;
+  export function writeTextFile(path: string, data: string): Promise<void>;
+  export function readFile(path: string): Promise<Uint8Array>;
+  export function readTextFile(path: string): Promise<string>;
+  export function exists(path: string): Promise<boolean>;
+  export function remove(path: string): Promise<void>;
+  export function readDir(path: string): Promise<Array<{ name: string | null }>>;
+}
+
+declare module '@tauri-apps/api/path' {
+  export function appDataDir(): Promise<string>;
+  export function join(...paths: string[]): Promise<string>;
+}