@ifc-lite/viewer 1.17.3 → 1.17.4

package/src/utils/desktopModelSnapshot.ts

@@ -0,0 +1,358 @@
+/* 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/. */
+
+import {
+  IfcTypeEnum,
+  IfcTypeEnumToString,
+  PropertyTableBuilder,
+  PropertyValueType,
+  QuantityTableBuilder,
+  type PropertyTable,
+  type QuantityTable,
+  type SpatialHierarchy,
+  type SpatialNode,
+} from '@ifc-lite/data';
+import {
+  BinaryCacheReader,
+  BinaryCacheWriter,
+  SchemaVersion as CacheSchemaVersion,
+  type IfcDataStore as CacheDataStore,
+} from '@ifc-lite/cache';
+import { extractPropertiesOnDemand, extractQuantitiesOnDemand, type IfcDataStore } from '@ifc-lite/parser';
+import { rebuildOnDemandMaps } from './spatialHierarchy.js';
+
+interface SerializedSpatialNode {
+  expressId: number;
+  type: number;
+  name: string;
+  elevation?: number;
+  children: SerializedSpatialNode[];
+  elements: number[];
+}
+
+interface SerializedSpatialHierarchy {
+  project: SerializedSpatialNode;
+  byStorey: Array<[number, number[]]>;
+  byBuilding: Array<[number, number[]]>;
+  bySite: Array<[number, number[]]>;
+  bySpace: Array<[number, number[]]>;
+  storeyElevations: Array<[number, number]>;
+  storeyHeights: Array<[number, number]>;
+  elementToStorey: Array<[number, number]>;
+}
+
+interface SerializedDesktopMetadataSnapshot {
+  version: number;
+  schemaVersion: IfcDataStore['schemaVersion'];
+  fileSize: number;
+  entityCount: number;
+  parseTime: number;
+  spatialHierarchy: SerializedSpatialHierarchy | null;
+  propertySetIds: number[];
+  quantitySetIds: number[];
+}
+
+interface DecodedDesktopMetadataSnapshot {
+  cacheBuffer: ArrayBuffer;
+  metadata: SerializedDesktopMetadataSnapshot;
+}
+
+const SNAPSHOT_VERSION = 2;
+
+function toCacheSchemaVersion(schemaVersion: IfcDataStore['schemaVersion']): CacheSchemaVersion {
+  switch (schemaVersion) {
+    case 'IFC4':
+      return CacheSchemaVersion.IFC4;
+    case 'IFC4X3':
+      return CacheSchemaVersion.IFC4X3;
+    default:
+      return CacheSchemaVersion.IFC2X3;
+  }
+}
+
+function serializeSpatialNode(node: SpatialNode): SerializedSpatialNode {
+  return {
+    expressId: node.expressId,
+    type: node.type,
+    name: node.name,
+    elevation: node.elevation,
+    children: node.children.map(serializeSpatialNode),
+    elements: [...node.elements],
+  };
+}
+
+function deserializeSpatialNode(node: SerializedSpatialNode): SpatialNode {
+  return {
+    expressId: node.expressId,
+    type: node.type as IfcTypeEnum,
+    name: node.name,
+    elevation: node.elevation,
+    children: node.children.map(deserializeSpatialNode),
+    elements: [...node.elements],
+  };
+}
+
+function serializeSpatialHierarchy(spatialHierarchy: SpatialHierarchy | undefined): SerializedSpatialHierarchy | null {
+  if (!spatialHierarchy) return null;
+  return {
+    project: serializeSpatialNode(spatialHierarchy.project),
+    byStorey: [...spatialHierarchy.byStorey.entries()].map(([id, elements]) => [id, [...elements]]),
+    byBuilding: [...spatialHierarchy.byBuilding.entries()].map(([id, elements]) => [id, [...elements]]),
+    bySite: [...spatialHierarchy.bySite.entries()].map(([id, elements]) => [id, [...elements]]),
+    bySpace: [...spatialHierarchy.bySpace.entries()].map(([id, elements]) => [id, [...elements]]),
+    storeyElevations: [...spatialHierarchy.storeyElevations.entries()],
+    storeyHeights: [...spatialHierarchy.storeyHeights.entries()],
+    elementToStorey: [...spatialHierarchy.elementToStorey.entries()],
+  };
+}
+
+function deserializeSpatialHierarchy(
+  serialized: SerializedSpatialHierarchy | null | undefined,
+): SpatialHierarchy | undefined {
+  if (!serialized) return undefined;
+
+  const project = deserializeSpatialNode(serialized.project);
+  const byStorey = new Map<number, number[]>(serialized.byStorey.map(([id, elements]) => [id, [...elements]]));
+  const byBuilding = new Map<number, number[]>(serialized.byBuilding.map(([id, elements]) => [id, [...elements]]));
+  const bySite = new Map<number, number[]>(serialized.bySite.map(([id, elements]) => [id, [...elements]]));
+  const bySpace = new Map<number, number[]>(serialized.bySpace.map(([id, elements]) => [id, [...elements]]));
+  const storeyElevations = new Map<number, number>(serialized.storeyElevations);
+  const storeyHeights = new Map<number, number>(serialized.storeyHeights);
+  const elementToStorey = new Map<number, number>(serialized.elementToStorey);
+  const elementToSpace = new Map<number, number>();
+
+  for (const [spaceId, elementIds] of bySpace) {
+    for (const elementId of elementIds) {
+      elementToSpace.set(elementId, spaceId);
+    }
+  }
+
+  return {
+    project,
+    byStorey,
+    byBuilding,
+    bySite,
+    bySpace,
+    storeyElevations,
+    storeyHeights,
+    elementToStorey,
+    getStoreyElements(storeyId: number): number[] {
+      return byStorey.get(storeyId) ?? [];
+    },
+    getStoreyByElevation(z: number): number | null {
+      let bestStoreyId: number | null = null;
+      let bestDistance = Number.POSITIVE_INFINITY;
+      for (const [storeyId, elevation] of storeyElevations) {
+        const distance = Math.abs(elevation - z);
+        if (distance < bestDistance) {
+          bestDistance = distance;
+          bestStoreyId = storeyId;
+        }
+      }
+      return bestStoreyId;
+    },
+    getContainingSpace(elementId: number): number | null {
+      return elementToSpace.get(elementId) ?? null;
+    },
+    getPath(elementId: number): SpatialNode[] {
+      const path: SpatialNode[] = [];
+      const walk = (node: SpatialNode): boolean => {
+        path.push(node);
+        if (node.elements.includes(elementId)) {
+          return true;
+        }
+        for (const child of node.children) {
+          if (walk(child)) {
+            return true;
+          }
+        }
+        path.pop();
+        return false;
+      };
+      walk(project);
+      return path;
+    },
+  };
+}
+
+function encodeSnapshotEnvelope(cacheBuffer: ArrayBuffer, metadata: SerializedDesktopMetadataSnapshot): ArrayBuffer {
+  const metadataBytes = new TextEncoder().encode(JSON.stringify(metadata));
+  const cacheBytes = new Uint8Array(cacheBuffer);
+  const out = new Uint8Array(4 + metadataBytes.length + cacheBytes.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, metadataBytes.length, true);
+  out.set(metadataBytes, 4);
+  out.set(cacheBytes, 4 + metadataBytes.length);
+  return out.buffer;
+}
+
+function collectSnapshotIndexIds(dataStore: IfcDataStore): { propertySetIds: number[]; quantitySetIds: number[] } {
+  return {
+    propertySetIds: [
+      ...(dataStore.entityIndex.byType.get('IFCPROPERTYSET') ?? dataStore.entityIndex.byType.get('IfcPropertySet') ?? []),
+    ],
+    quantitySetIds: [
+      ...(dataStore.entityIndex.byType.get('IFCELEMENTQUANTITY') ?? dataStore.entityIndex.byType.get('IfcElementQuantity') ?? []),
+    ],
+  };
+}
+
+function buildEntityIndexByType(
+  dataStore: Pick<IfcDataStore, 'entities'>,
+  propertySetIds: number[],
+  quantitySetIds: number[],
+): Map<string, number[]> {
+  const byType = new Map<string, number[]>();
+  for (let i = 0; i < dataStore.entities.count; i++) {
+    const typeName = IfcTypeEnumToString(dataStore.entities.typeEnum[i]).toUpperCase();
+    const expressId = dataStore.entities.expressId[i];
+    let ids = byType.get(typeName);
+    if (!ids) {
+      ids = [];
+      byType.set(typeName, ids);
+    }
+    ids.push(expressId);
+  }
+  if (propertySetIds.length > 0) {
+    byType.set('IFCPROPERTYSET', [...propertySetIds]);
+  }
+  if (quantitySetIds.length > 0) {
+    byType.set('IFCELEMENTQUANTITY', [...quantitySetIds]);
+  }
+  return byType;
+}
+
+function decodeSnapshotEnvelope(buffer: ArrayBuffer): DecodedDesktopMetadataSnapshot {
+  const bytes = new Uint8Array(buffer);
+  const view = new DataView(buffer);
+  const metadataLength = view.getUint32(0, true);
+  const metadataBytes = bytes.subarray(4, 4 + metadataLength);
+  const cacheBytes = bytes.subarray(4 + metadataLength);
+  const metadata = JSON.parse(new TextDecoder().decode(metadataBytes)) as SerializedDesktopMetadataSnapshot;
+  return {
+    cacheBuffer: cacheBytes.slice().buffer,
+    metadata,
+  };
+}
+
+function materializeSnapshotPropertyTable(dataStore: IfcDataStore): PropertyTable {
+  if (dataStore.properties.count > 0 || !dataStore.source?.length || !dataStore.onDemandPropertyMap?.size) {
+    return dataStore.properties;
+  }
+
+  const builder = new PropertyTableBuilder(dataStore.strings);
+  for (const entityId of dataStore.onDemandPropertyMap.keys()) {
+    const propertySets = extractPropertiesOnDemand(dataStore, entityId);
+    for (const propertySet of propertySets) {
+      for (const property of propertySet.properties) {
+        builder.add({
+          entityId,
+          psetName: propertySet.name,
+          psetGlobalId: propertySet.globalId ?? '',
+          propName: property.name,
+          propType: property.type as PropertyValueType,
+          value: property.value,
+        });
+      }
+    }
+  }
+  return builder.build();
+}
+
+function materializeSnapshotQuantityTable(dataStore: IfcDataStore): QuantityTable {
+  if (dataStore.quantities.count > 0 || !dataStore.source?.length || !dataStore.onDemandQuantityMap?.size) {
+    return dataStore.quantities;
+  }
+
+  const builder = new QuantityTableBuilder(dataStore.strings);
+  for (const entityId of dataStore.onDemandQuantityMap.keys()) {
+    const quantitySets = extractQuantitiesOnDemand(dataStore, entityId);
+    for (const quantitySet of quantitySets) {
+      for (const quantity of quantitySet.quantities) {
+        builder.add({
+          entityId,
+          qsetName: quantitySet.name,
+          quantityName: quantity.name,
+          quantityType: quantity.type,
+          value: quantity.value,
+        });
+      }
+    }
+  }
+  return builder.build();
+}
+
+export async function buildDesktopMetadataSnapshot(
+  dataStore: IfcDataStore,
+  sourceBuffer: ArrayBuffer,
+): Promise<ArrayBuffer> {
+  const writer = new BinaryCacheWriter();
+  const properties = materializeSnapshotPropertyTable(dataStore);
+  const quantities = materializeSnapshotQuantityTable(dataStore);
+  const cacheDataStore: CacheDataStore = {
+    schema: toCacheSchemaVersion(dataStore.schemaVersion),
+    entityCount: dataStore.entityCount || dataStore.entities?.count || 0,
+    strings: dataStore.strings,
+    entities: dataStore.entities,
+    properties,
+    quantities,
+    relationships: dataStore.relationships,
+    spatialHierarchy: dataStore.spatialHierarchy,
+  };
+
+  const cacheBuffer = await writer.write(cacheDataStore, undefined, sourceBuffer, {
+    includeGeometry: false,
+    includeSpatialHierarchy: false,
+  });
+  const { propertySetIds, quantitySetIds } = collectSnapshotIndexIds(dataStore);
+
+  return encodeSnapshotEnvelope(cacheBuffer, {
+    version: SNAPSHOT_VERSION,
+    schemaVersion: dataStore.schemaVersion,
+    fileSize: dataStore.fileSize,
+    entityCount: dataStore.entityCount,
+    parseTime: dataStore.parseTime,
+    spatialHierarchy: serializeSpatialHierarchy(dataStore.spatialHierarchy),
+    propertySetIds,
+    quantitySetIds,
+  });
+}
+
+export async function restoreDesktopMetadataSnapshot(
+  snapshotBuffer: ArrayBuffer,
+): Promise<IfcDataStore> {
+  const { cacheBuffer, metadata } = decodeSnapshotEnvelope(snapshotBuffer);
+  if (metadata.version !== SNAPSHOT_VERSION) {
+    throw new Error(`unsupported-desktop-metadata-snapshot:${metadata.version}`);
+  }
+  const reader = new BinaryCacheReader();
+  const result = await reader.read(cacheBuffer, { skipGeometry: true });
+  const dataStore = result.dataStore as unknown as IfcDataStore;
+  const byType = buildEntityIndexByType(
+    dataStore,
+    metadata.propertySetIds ?? [],
+    metadata.quantitySetIds ?? [],
+  );
+
+  dataStore.fileSize = metadata.fileSize;
+  dataStore.schemaVersion = metadata.schemaVersion;
+  dataStore.entityCount = metadata.entityCount;
+  dataStore.parseTime = metadata.parseTime;
+  dataStore.source = new Uint8Array(0);
+  dataStore.entityIndex = {
+    byId: new Map() as IfcDataStore['entityIndex']['byId'],
+    byType,
+  };
+  dataStore.spatialHierarchy = deserializeSpatialHierarchy(metadata.spatialHierarchy);
+
+  const { onDemandPropertyMap, onDemandQuantityMap } = rebuildOnDemandMaps(
+    dataStore.entities,
+    dataStore.relationships,
+    dataStore.entityIndex,
+  );
+  dataStore.onDemandPropertyMap = onDemandPropertyMap;
+  dataStore.onDemandQuantityMap = onDemandQuantityMap;
+
+  return dataStore;
+}

package/src/utils/ifcConfig.ts

@@ -46,6 +46,9 @@ export const CACHE_SIZE_THRESHOLD = 10 * 1024 * 1024;
  *  and including it would make the IndexedDB write prohibitively large. */
 export const CACHE_MAX_SOURCE_SIZE = 150 * 1024 * 1024;
 
+/** Route desktop IFCs above this threshold through the bounded-memory path. */
+export const HUGE_NATIVE_FILE_THRESHOLD = 128 * 1024 * 1024;
+
 /** File size thresholds for various optimizations */
 export const THRESHOLDS = {
   /** Use streaming Parquet above this (150MB) */
@@ -65,7 +68,9 @@ export const THRESHOLDS = {
 // ============================================================================
 
 /** Detect if running in Tauri (desktop) environment */
-export const isTauri = typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
+export function isTauri(): boolean {
+  return typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
+}
 
 // ============================================================================
 // Dynamic Batch Configuration

package/src/utils/nativeSpatialDataStore.ts

@@ -0,0 +1,250 @@
+/* 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/. */
+
+import {
+  IfcTypeEnumFromString,
+  isBuildingLikeSpatialType,
+  isStoreyLikeSpatialType,
+  type SpatialHierarchy,
+  type SpatialNode,
+} from '@ifc-lite/data';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { NativeMetadataEntitySummary, NativeMetadataSnapshot, NativeMetadataSpatialNode } from '@/store/types';
+
+function normalizeSummary(summary: Partial<NativeMetadataEntitySummary> & { typeName?: string; summary?: Partial<NativeMetadataEntitySummary> }): NativeMetadataEntitySummary | null {
+  const source = summary.summary ? { ...summary.summary, ...summary } : summary;
+  const expressId = typeof source.expressId === 'number' ? source.expressId : null;
+  const type = typeof source.type === 'string'
+    ? source.type
+    : typeof source.typeName === 'string'
+      ? source.typeName
+      : null;
+  if (expressId === null || !type) {
+    return null;
+  }
+  return {
+    expressId,
+    type,
+    name: typeof source.name === 'string' ? source.name : `${type} #${expressId}`,
+    globalId: typeof source.globalId === 'string' ? source.globalId : null,
+    kind: source.kind === 'spatial' ? 'spatial' : 'element',
+    hasChildren: Boolean(source.hasChildren),
+    elementCount: typeof source.elementCount === 'number' ? source.elementCount : undefined,
+    elevation: typeof source.elevation === 'number' ? source.elevation : undefined,
+  };
+}
+
+function normalizeSpatialNode(
+  node: NativeMetadataSpatialNode | (Partial<NativeMetadataSpatialNode> & { typeName?: string; summary?: Partial<NativeMetadataEntitySummary> }),
+): (NativeMetadataSpatialNode & { elements: NativeMetadataEntitySummary[] }) | null {
+  const summary = normalizeSummary(node as Partial<NativeMetadataEntitySummary> & { typeName?: string; summary?: Partial<NativeMetadataEntitySummary> });
+  if (!summary) {
+    return null;
+  }
+  const children = Array.isArray(node.children)
+    ? node.children
+        .map((child) => normalizeSpatialNode(child as Partial<NativeMetadataSpatialNode> & { typeName?: string; summary?: Partial<NativeMetadataEntitySummary> }))
+        .filter((child): child is NativeMetadataSpatialNode & { elements: NativeMetadataEntitySummary[] } => child !== null)
+    : [];
+  const elements = Array.isArray((node as { elements?: unknown[] }).elements)
+    ? ((node as { elements?: unknown[] }).elements ?? [])
+        .map((entry) => normalizeSummary(entry as Partial<NativeMetadataEntitySummary> & { typeName?: string; summary?: Partial<NativeMetadataEntitySummary> }))
+        .filter((entry): entry is NativeMetadataEntitySummary => entry !== null)
+    : [];
+  return {
+    ...summary,
+    children,
+    elements,
+  };
+}
+
+function buildEntityLookup() {
+  const ids: number[] = [];
+  const typeEnums: number[] = [];
+  const flags: number[] = [];
+  const nameById = new Map<number, string>();
+  const typeNameById = new Map<number, string>();
+  const byType = new Map<string, number[]>();
+
+  const addSummary = (summary: NativeMetadataEntitySummary) => {
+    if (!summary.type) {
+      return;
+    }
+    if (nameById.has(summary.expressId)) {
+      return;
+    }
+    ids.push(summary.expressId);
+    typeEnums.push(IfcTypeEnumFromString(summary.type));
+    flags.push(0);
+    nameById.set(summary.expressId, summary.name);
+    typeNameById.set(summary.expressId, summary.type);
+    const typeKey = summary.type.toUpperCase();
+    const existing = byType.get(typeKey);
+    if (existing) {
+      existing.push(summary.expressId);
+    } else {
+      byType.set(typeKey, [summary.expressId]);
+    }
+  };
+
+  return {
+    addSummary,
+    buildEntities() {
+      return {
+        count: ids.length,
+        expressId: Uint32Array.from(ids),
+        typeEnum: Uint32Array.from(typeEnums),
+        flags: Uint8Array.from(flags),
+        getName(expressId: number) {
+          return nameById.get(expressId);
+        },
+        getTypeName(expressId: number) {
+          return typeNameById.get(expressId) ?? 'Unknown';
+        },
+        getByType(type: string | number) {
+          const key = typeof type === 'string' ? type.toUpperCase() : String(type);
+          return byType.get(key) ?? [];
+        },
+      };
+    },
+    buildByType() {
+      return byType;
+    },
+  };
+}
+
+function buildPathResolver(project: SpatialNode) {
+  return (elementId: number): SpatialNode[] => {
+    const path: SpatialNode[] = [];
+    const visit = (node: SpatialNode): boolean => {
+      path.push(node);
+      if (node.elements.includes(elementId)) {
+        return true;
+      }
+      for (const child of node.children) {
+        if (visit(child)) {
+          return true;
+        }
+      }
+      path.pop();
+      return false;
+    };
+    visit(project);
+    return path;
+  };
+}
+
+export function buildIfcDataStoreFromNativeMetadata(snapshot: NativeMetadataSnapshot): IfcDataStore | null {
+  const root = snapshot.spatialTree ? normalizeSpatialNode(snapshot.spatialTree) : null;
+  if (!root) {
+    return null;
+  }
+
+  const byStorey = new Map<number, number[]>();
+  const byBuilding = new Map<number, number[]>();
+  const bySite = new Map<number, number[]>();
+  const bySpace = new Map<number, number[]>();
+  const storeyElevations = new Map<number, number>();
+  const storeyHeights = new Map<number, number>();
+  const elementToStorey = new Map<number, number>();
+  const elementToSpace = new Map<number, number>();
+  const entityLookup = buildEntityLookup();
+
+  const buildNode = (
+    node: NativeMetadataSpatialNode & { elements: NativeMetadataEntitySummary[] },
+    currentStoreyId: number | null,
+    currentSpaceId: number | null,
+  ): SpatialNode => {
+    entityLookup.addSummary(node);
+    const typeEnum = IfcTypeEnumFromString(node.type);
+    const nextStoreyId = isStoreyLikeSpatialType(typeEnum) ? node.expressId : currentStoreyId;
+    const nextSpaceId = node.type === 'IfcSpace' ? node.expressId : currentSpaceId;
+    const elements = node.elements.map((summary) => {
+      entityLookup.addSummary(summary);
+      if (nextStoreyId !== null) {
+        elementToStorey.set(summary.expressId, nextStoreyId);
+      }
+      if (nextSpaceId !== null) {
+        elementToSpace.set(summary.expressId, nextSpaceId);
+      }
+      return summary.expressId;
+    });
+
+    const childNodes = node.children.map((child) => buildNode(child, nextStoreyId, nextSpaceId));
+    const spatialNode: SpatialNode = {
+      expressId: node.expressId,
+      type: typeEnum,
+      name: node.name,
+      elevation: node.elevation ?? undefined,
+      children: childNodes,
+      elements,
+    };
+
+    if (isStoreyLikeSpatialType(typeEnum)) {
+      byStorey.set(node.expressId, elements);
+      if (typeof node.elevation === 'number') {
+        storeyElevations.set(node.expressId, node.elevation);
+      }
+    } else if (isBuildingLikeSpatialType(typeEnum)) {
+      byBuilding.set(node.expressId, elements);
+    } else if (node.type === 'IfcSite') {
+      bySite.set(node.expressId, elements);
+    } else if (node.type === 'IfcSpace') {
+      bySpace.set(node.expressId, elements);
+    }
+
+    return spatialNode;
+  };
+
+  const project = buildNode(root, null, null);
+  const getPath = buildPathResolver(project);
+  const hierarchy: SpatialHierarchy = {
+    project,
+    byStorey,
+    byBuilding,
+    bySite,
+    bySpace,
+    storeyElevations,
+    storeyHeights,
+    elementToStorey,
+    getStoreyElements(storeyId: number) {
+      return byStorey.get(storeyId) ?? [];
+    },
+    getStoreyByElevation(z: number) {
+      let closestStoreyId: number | null = null;
+      let closestDistance = Number.POSITIVE_INFINITY;
+      for (const [storeyId, elevation] of storeyElevations) {
+        const distance = Math.abs(elevation - z);
+        if (distance < closestDistance) {
+          closestDistance = distance;
+          closestStoreyId = storeyId;
+        }
+      }
+      return closestStoreyId;
+    },
+    getContainingSpace(elementId: number) {
+      return elementToSpace.get(elementId) ?? null;
+    },
+    getPath,
+  };
+
+  const entities = entityLookup.buildEntities();
+  return {
+    fileSize: 0,
+    schemaVersion: snapshot.schemaVersion,
+    entityCount: snapshot.entityCount,
+    parseTime: 0,
+    source: new Uint8Array(0),
+    entityIndex: {
+      byId: new Map(),
+      byType: entityLookup.buildByType(),
+    },
+    strings: {} as IfcDataStore['strings'],
+    entities: entities as unknown as IfcDataStore['entities'],
+    properties: undefined as unknown as IfcDataStore['properties'],
+    quantities: undefined as unknown as IfcDataStore['quantities'],
+    relationships: undefined as unknown as IfcDataStore['relationships'],
+    spatialHierarchy: hierarchy,
+  } as IfcDataStore;
+}

package/src/utils/serverDataModel.ts

@@ -394,6 +394,10 @@ function buildEntityTable(
       if (!indices) return [];
       return indices.map(idx => expressId[idx]);
     },
+    getTypeEnum: (id) => {
+      const i = indexOfId(id);
+      return i >= 0 ? typeEnumArr[i] as IfcTypeEnum : IfcTypeEnum.Unknown;
+    },
     getExpressIdByGlobalId: (gid) => {
       return globalIdToExpressId.get(gid) ?? -1;
     },

package/src/utils/spatialHierarchy.ts

@@ -32,12 +32,9 @@ export function rebuildSpatialHierarchy(
   entities: EntityTable,
   relationships: RelationshipGraph
 ): SpatialHierarchy | undefined {
-  // PRE-BUILD INDEX MAP: O(n) once, then O(1) lookups
-  // This eliminates the O(n²) nested loops from before
-  const entityTypeMap = new Map<number, IfcTypeEnum>();
-  for (let i = 0; i < entities.count; i++) {
-    entityTypeMap.set(entities.expressId[i], entities.typeEnum[i]);
-  }
+  // Use EntityTable.getTypeEnum() for O(1) lookups via its internal idToIndex map.
+  // This avoids building a temporary Map<number, IfcTypeEnum> with 4.4M entries
+  // (~350MB for large files) that duplicates data already in the entity table.
 
   const byStorey = new Map<number, number[]>();
   const byBuilding = new Map<number, number[]>();
@@ -58,7 +55,7 @@ export function rebuildSpatialHierarchy(
   // Build node tree recursively - NOW O(1) lookups!
   function buildNode(expressId: number): SpatialNode {
     // O(1) lookup instead of O(n) linear search
-    const typeEnum = entityTypeMap.get(expressId) ?? IfcTypeEnum.Unknown;
+    const typeEnum = entities.getTypeEnum(expressId);
     const name = entities.getName(expressId) || `Entity #${expressId}`;
 
     // Get contained elements via IfcRelContainedInSpatialStructure
@@ -68,10 +65,12 @@ export function rebuildSpatialHierarchy(
       'forward'
     );
 
-    // Filter out spatial structure elements - O(1) per element now!
+    // Filter out spatial structure elements — keep unknown types (custom/newer IFC classes).
+    // getTypeEnum() returns IfcTypeEnum.Unknown for both missing and unrecognized entities;
+    // isSpatialStructureType(Unknown) is false, so unknown types pass through correctly.
     const containedElements = rawContainedElements.filter((id) => {
-      const elemType = entityTypeMap.get(id);
-      return elemType !== undefined && !isSpatialStructureType(elemType);
+      const elemType = entities.getTypeEnum(id);
+      return !isSpatialStructureType(elemType);
     });
 
     // Get aggregated children via IfcRelAggregates
@@ -84,7 +83,7 @@ export function rebuildSpatialHierarchy(
     // Filter to spatial structure types and recurse - O(1) per child now!
     const childNodes: SpatialNode[] = [];
     for (const childId of aggregatedChildren) {
-      const childType = entityTypeMap.get(childId);
+      const childType = entities.getTypeEnum(childId);
       if (childType && isSpatialStructureType(childType) && childType !== IfcTypeEnum.IfcProject) {
         childNodes.push(buildNode(childId));
       }