@ifc-lite/parser 9.1.0 → 9.5.0

package/dist/material-resolver.js

@@ -7,10 +7,12 @@
  * Includes cycle detection for recursive material references.
  */
 import { EntityExtractor } from './entity-extractor.js';
+import { getReference, getReferences } from './attribute-helpers.js';
+import { materialRecordReader, materialAssignmentState } from './material-overlay.js';
+import { resolveMaterial } from './material-definitions.js';
 import { RelationshipType } from '@ifc-lite/data';
 import { isIfcTypeLikeEntity } from './columnar-parser-indexes.js';
-import { resolveEntityLengthUnitScale } from './unit-extractor.js';
-import { resolveAllMaterialDefIds, resolveMaterialOwnerAndDefIds, resolveOwnMaterialDefIds } from './material-associations.js';
+import { resolveAllMaterialDefIds, resolveOwnMaterialDefIds } from './material-associations.js';
 export { resolveAllMaterialDefIds } from './material-associations.js';
 /**
  * Extract EVERY material association for an entity ON-DEMAND, resolved to
@@ -19,25 +21,29 @@ export { resolveAllMaterialDefIds } from './material-associations.js';
  * fallback IfcMaterial yield several. Order matches
  * {@link resolveAllMaterialDefIds}. Consumers that need a single value use
  * {@link extractMaterialsOnDemand} (=== element 0 here).
+ * An optional native view applies current assignments, aliases and material edits.
  */
-export function extractAllMaterialsOnDemand(store, entityId) {
-    const { ownerId, defIds } = resolveMaterialOwnerAndDefIds(store, entityId);
-    if (defIds.length === 0)
-        return [];
-    if (!store.source?.length) {
-        const resolved = store.resolvedMaterials?.get(ownerId);
-        // A missing or older wire row stays unverified. Never let a partial
-        // forwarding payload convert an unknown value into a confident mismatch.
-        return defIds.map((id) => resolved?.get(id) ?? { type: 'Material', unresolved: true });
-    }
-    const extractor = new EntityExtractor(store.source);
-    const out = [];
-    for (const defId of defIds) {
-        const info = resolveMaterial(store, extractor, defId, new Set(), entityId);
-        if (info)
-            out.push(info);
-    }
-    return out;
+export function extractAllMaterialsOnDemand(store, entityId, view) {
+    const { ownerId, defIds, complete } = materialAssignmentState(store, entityId, view);
+    const read = materialRecordReader(store, view);
+    return defIds.map((id) => {
+        const record = read(id);
+        if (!store.source?.length) {
+            const edits = view?.getEffectiveChanges?.().some(edit => {
+                if (!['attribute', 'type', 'entity-deleted'].includes(edit.kind))
+                    return false;
+                // @raw-entity-enumeration-ok Immutable source kind identifies a current effective edit; material membership and values come from the effective reader.
+                const sourceType = store.entityIndex.byId.get(edit.entityId)?.type ?? store.deferredEntityIndex?.get(edit.entityId)?.type;
+                return edit.entityId === id || Boolean(sourceType?.toUpperCase().startsWith('IFCMATERIAL'));
+            });
+            const forwarded = complete && !edits ? store.resolvedMaterials?.get(ownerId)?.get(id) : undefined;
+            if (forwarded)
+                return forwarded;
+            if (!record || record.type.toUpperCase() !== 'IFCMATERIAL')
+                return { type: 'Material', unresolved: true };
+        }
+        return resolveMaterial(store, read, id, new Set(), view?.resolveBaseEntityId?.(entityId) ?? entityId) ?? { type: 'Material', unresolved: true };
+    });
 }
 /**
  * Extract materials for a single entity ON-DEMAND.
@@ -48,226 +54,9 @@ export function extractAllMaterialsOnDemand(store, entityId) {
  * Returns the entity's PRIMARY material (lowest-rel-express-id association);
  * use {@link extractAllMaterialsOnDemand} when every association matters.
  */
-export function extractMaterialsOnDemand(store, entityId) {
-    const materialId = resolveAllMaterialDefIds(store, entityId)[0];
-    if (materialId === undefined)
-        return null;
-    if (!store.source?.length) {
-        const info = extractAllMaterialsOnDemand(store, entityId)[0];
-        return info?.unresolved ? null : info ?? null;
-    }
-    const extractor = new EntityExtractor(store.source);
-    return resolveMaterial(store, extractor, materialId, new Set(), entityId);
-}
-/**
- * Resolve a material entity by ID, handling all IFC material types. `visited`
- * guards cyclic *Usage references; `originEntityId` (the calling element/type)
- * lets a layer's thickness resolve its own project's unit scale below.
- */
-function resolveMaterial(store, extractor, materialId, visited = new Set(), originEntityId) {
-    if (visited.has(materialId))
-        return null;
-    visited.add(materialId);
-    // @raw-entity-enumeration-ok decode the selected material definition's one source STEP record
-    const ref = store.entityIndex.byId.get(materialId);
-    if (!ref)
-        return null;
-    const entity = extractor.extractEntity(ref);
-    if (!entity)
-        return null;
-    const typeUpper = entity.type.toUpperCase();
-    const attrs = entity.attributes || [];
-    switch (typeUpper) {
-        case 'IFCMATERIAL': {
-            // IfcMaterial: [Name, Description, Category]
-            return {
-                type: 'Material',
-                name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
-                description: typeof attrs[1] === 'string' ? attrs[1] : undefined,
-                category: typeof attrs[2] === 'string' ? attrs[2] : undefined,
-            };
-        }
-        case 'IFCMATERIALLAYERSET': {
-            // IfcMaterialLayerSet: [MaterialLayers, LayerSetName, Description]
-            const layerIds = Array.isArray(attrs[0]) ? attrs[0].filter((id) => typeof id === 'number') : [];
-            const layers = [];
-            for (const layerId of layerIds) {
-                // @raw-entity-enumeration-ok decode this material set's referenced layer record
-                const layerRef = store.entityIndex.byId.get(layerId);
-                if (!layerRef)
-                    continue;
-                const layerEntity = extractor.extractEntity(layerRef);
-                if (!layerEntity)
-                    continue;
-                const la = layerEntity.attributes || [];
-                // IfcMaterialLayer: [Material, LayerThickness, IsVentilated, Name, Description, Category, Priority]
-                const matId = typeof la[0] === 'number' ? la[0] : undefined;
-                let materialName;
-                let materialCategory;
-                if (matId) {
-                    // @raw-entity-enumeration-ok decode the layer's referenced material record
-                    const matRef = store.entityIndex.byId.get(matId);
-                    if (matRef) {
-                        const matEntity = extractor.extractEntity(matRef);
-                        if (matEntity) {
-                            materialName = typeof matEntity.attributes?.[0] === 'string' ? matEntity.attributes[0] : undefined;
-                            materialCategory = typeof matEntity.attributes?.[2] === 'string' ? matEntity.attributes[2] : undefined;
-                        }
-                    }
-                }
-                // Convert raw IFC value to metres (a 60 mm slab must not read
-                // "60.0 m"). `store.lengthUnitScale` answers for the file's
-                // FIRST IfcProject only, wrong for a MergedExporter federated
-                // layer in a LATER project — resolve per `originEntityId`.
-                const rawThickness = typeof la[1] === 'number' ? la[1] : undefined;
-                const scale = originEntityId !== undefined ? resolveEntityLengthUnitScale(store.source, store.entityIndex, store.relationships, originEntityId) : (store.lengthUnitScale ?? 1);
-                const thickness = rawThickness !== undefined ? rawThickness * scale : undefined;
-                layers.push({
-                    materialName,
-                    thickness,
-                    isVentilated: la[2] === true || la[2] === '.T.',
-                    name: typeof la[3] === 'string' ? la[3] : undefined,
-                    category: typeof la[5] === 'string' ? la[5] : undefined,
-                    materialCategory,
-                });
-            }
-            return {
-                type: 'MaterialLayerSet',
-                name: typeof attrs[1] === 'string' ? attrs[1] : undefined,
-                description: typeof attrs[2] === 'string' ? attrs[2] : undefined,
-                layers,
-            };
-        }
-        case 'IFCMATERIALPROFILESET': {
-            // IfcMaterialProfileSet: [Name, Description, MaterialProfiles, CompositeProfile]
-            const profileIds = Array.isArray(attrs[2]) ? attrs[2].filter((id) => typeof id === 'number') : [];
-            const profiles = [];
-            for (const profId of profileIds) {
-                // @raw-entity-enumeration-ok decode this profile set's referenced profile record
-                const profRef = store.entityIndex.byId.get(profId);
-                if (!profRef)
-                    continue;
-                const profEntity = extractor.extractEntity(profRef);
-                if (!profEntity)
-                    continue;
-                const pa = profEntity.attributes || [];
-                // IfcMaterialProfile: [Name, Description, Material, Profile, Priority, Category]
-                const matId = typeof pa[2] === 'number' ? pa[2] : undefined;
-                let materialName;
-                let materialCategory;
-                if (matId) {
-                    // @raw-entity-enumeration-ok decode the profile's referenced material record
-                    const matRef = store.entityIndex.byId.get(matId);
-                    if (matRef) {
-                        const matEntity = extractor.extractEntity(matRef);
-                        if (matEntity) {
-                            materialName = typeof matEntity.attributes?.[0] === 'string' ? matEntity.attributes[0] : undefined;
-                            materialCategory = typeof matEntity.attributes?.[2] === 'string' ? matEntity.attributes[2] : undefined;
-                        }
-                    }
-                }
-                profiles.push({
-                    materialName,
-                    name: typeof pa[0] === 'string' ? pa[0] : undefined,
-                    category: typeof pa[5] === 'string' ? pa[5] : undefined,
-                    materialCategory,
-                });
-            }
-            return {
-                type: 'MaterialProfileSet',
-                name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
-                description: typeof attrs[1] === 'string' ? attrs[1] : undefined,
-                profiles,
-            };
-        }
-        case 'IFCMATERIALCONSTITUENTSET': {
-            // IfcMaterialConstituentSet: [Name, Description, MaterialConstituents]
-            const constituentIds = Array.isArray(attrs[2]) ? attrs[2].filter((id) => typeof id === 'number') : [];
-            const constituents = [];
-            for (const constId of constituentIds) {
-                // @raw-entity-enumeration-ok decode this constituent set's referenced constituent record
-                const constRef = store.entityIndex.byId.get(constId);
-                if (!constRef)
-                    continue;
-                const constEntity = extractor.extractEntity(constRef);
-                if (!constEntity)
-                    continue;
-                const ca = constEntity.attributes || [];
-                // IfcMaterialConstituent: [Name, Description, Material, Fraction, Category]
-                const matId = typeof ca[2] === 'number' ? ca[2] : undefined;
-                let materialName;
-                let materialCategory;
-                if (matId) {
-                    // @raw-entity-enumeration-ok decode the constituent's referenced material record
-                    const matRef = store.entityIndex.byId.get(matId);
-                    if (matRef) {
-                        const matEntity = extractor.extractEntity(matRef);
-                        if (matEntity) {
-                            materialName = typeof matEntity.attributes?.[0] === 'string' ? matEntity.attributes[0] : undefined;
-                            // IfcMaterial: [Name, Description, Category] — IDS material
-                            // checks consider both the constituent's own category AND
-                            // the underlying IfcMaterial.Category as candidates for
-                            // a value match.
-                            materialCategory = typeof matEntity.attributes?.[2] === 'string' ? matEntity.attributes[2] : undefined;
-                        }
-                    }
-                }
-                constituents.push({
-                    materialName,
-                    name: typeof ca[0] === 'string' ? ca[0] : undefined,
-                    fraction: typeof ca[3] === 'number' ? ca[3] : undefined,
-                    category: typeof ca[4] === 'string' ? ca[4] : undefined,
-                    materialCategory,
-                });
-            }
-            return {
-                type: 'MaterialConstituentSet',
-                name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
-                description: typeof attrs[1] === 'string' ? attrs[1] : undefined,
-                constituents,
-            };
-        }
-        case 'IFCMATERIALLIST': {
-            // IfcMaterialList: [Materials]
-            const matIds = Array.isArray(attrs[0]) ? attrs[0].filter((id) => typeof id === 'number') : [];
-            const materials = [];
-            for (const matId of matIds) {
-                // @raw-entity-enumeration-ok decode this material list's referenced material record
-                const matRef = store.entityIndex.byId.get(matId);
-                if (!matRef)
-                    continue;
-                const matEntity = extractor.extractEntity(matRef);
-                if (matEntity) {
-                    const name = typeof matEntity.attributes?.[0] === 'string'
-                        ? matEntity.attributes[0] : `Material #${matId}`;
-                    const category = typeof matEntity.attributes?.[2] === 'string' ? matEntity.attributes[2] : undefined;
-                    materials.push({ name, ...(category ? { category } : {}) });
-                }
-            }
-            return {
-                type: 'MaterialList',
-                materials,
-            };
-        }
-        case 'IFCMATERIALLAYERSETUSAGE': {
-            // IfcMaterialLayerSetUsage: [ForLayerSet, LayerSetDirection, DirectionSense, OffsetFromReferenceLine, ...]
-            const layerSetId = typeof attrs[0] === 'number' ? attrs[0] : undefined;
-            if (layerSetId) {
-                return resolveMaterial(store, extractor, layerSetId, visited, originEntityId);
-            }
-            return null;
-        }
-        case 'IFCMATERIALPROFILESETUSAGE': {
-            // IfcMaterialProfileSetUsage: [ForProfileSet, ...]
-            const profileSetId = typeof attrs[0] === 'number' ? attrs[0] : undefined;
-            if (profileSetId) {
-                return resolveMaterial(store, extractor, profileSetId, visited, originEntityId);
-            }
-            return null;
-        }
-        default:
-            return null;
-    }
+export function extractMaterialsOnDemand(store, entityId, view) {
+    const first = extractAllMaterialsOnDemand(store, entityId, view)[0];
+    return first?.unresolved ? null : first ?? null;
 }
 /** Resolve an entity ref from the primary index, falling back to deferred atoms. */
 function getRef(store, id) {
@@ -275,11 +64,8 @@ function getRef(store, id) {
     return store.entityIndex.byId.get(id) ?? store.deferredEntityIndex?.get(id);
 }
 /** Read an IfcMaterial's Name (attr 0) and Category (attr 2). */
-function readMaterialNameCategory(store, extractor, materialId) {
-    const ref = getRef(store, materialId);
-    if (!ref)
-        return {};
-    const entity = extractor.extractEntity(ref);
+function readMaterialNameCategory(read, materialId) {
+    const entity = read(materialId);
     const attrs = entity?.attributes ?? [];
     return {
         name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
@@ -303,7 +89,9 @@ const leavesCache = new WeakMap();
  * leaf with weight 1. Results are memoised per (store, defId) — a type-shared
  * layer set is resolved once for the whole model.
  */
-export function collectMaterialLeaves(store, defId) {
+export function collectMaterialLeaves(store, defId, view) {
+    if (view)
+        return resolveLeaves(materialRecordReader(store, view), defId, new Set());
     let cache = leavesCache.get(store);
     if (!cache) {
         cache = new Map();
@@ -312,10 +100,9 @@ export function collectMaterialLeaves(store, defId) {
     const cached = cache.get(defId);
     if (cached)
         return cached;
-    const extractor = store.source?.length ? new EntityExtractor(store.source) : null;
     let result;
-    if (extractor) {
-        result = resolveLeaves(store, extractor, defId, new Set());
+    if (store.source?.length) {
+        result = resolveLeaves(materialRecordReader(store), defId, new Set());
     }
     else {
         // Source-less store (server-loaded models keep `source` as an EMPTY
@@ -351,147 +138,145 @@ function mergeLeaves(into, leaf) {
 }
 /** Recursively resolve a material definition into weighted base-material leaves
  *  (cycle-guarded via `visited`). See {@link collectMaterialLeaves}. */
-function resolveLeaves(store, extractor, defId, visited) {
-    if (visited.has(defId))
-        return [];
-    visited.add(defId);
-    const ref = getRef(store, defId);
-    if (!ref)
-        return [];
-    const entity = extractor.extractEntity(ref);
-    if (!entity)
-        return [];
-    const typeUpper = entity.type.toUpperCase();
-    const attrs = entity.attributes || [];
-    const merged = new Map();
-    const addMaterialLeaf = (matId, weight) => {
-        if (matId === undefined)
-            return;
-        const { name, category } = readMaterialNameCategory(store, extractor, matId);
-        mergeLeaves(merged, { id: matId, name, category, weight });
-    };
-    switch (typeUpper) {
-        case 'IFCMATERIAL':
-            return [{
-                    id: defId,
-                    name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
-                    category: typeof attrs[2] === 'string' ? attrs[2] : undefined,
-                    weight: 1,
-                }];
-        case 'IFCMATERIALLAYERSET': {
-            // IfcMaterialLayerSet: [MaterialLayers, LayerSetName, Description]
-            const layerIds = Array.isArray(attrs[0]) ? attrs[0].filter((id) => typeof id === 'number') : [];
-            const layers = [];
-            for (const layerId of layerIds) {
-                const layerRef = getRef(store, layerId);
-                if (!layerRef)
-                    continue;
-                const la = extractor.extractEntity(layerRef)?.attributes ?? [];
-                // IfcMaterialLayer: [Material, LayerThickness, IsVentilated, Name, Description, Category, Priority]
-                layers.push({
-                    matId: typeof la[0] === 'number' ? la[0] : undefined,
-                    // Non-finite thickness would turn every weight into NaN
-                    // (Infinity/Infinity) - treat it as absent like <= 0.
-                    thickness: typeof la[1] === 'number' && Number.isFinite(la[1]) && la[1] > 0 ? la[1] : 0,
-                });
-            }
-            const totalThickness = layers.reduce((s, l) => s + l.thickness, 0);
-            for (const layer of layers) {
-                const weight = totalThickness > 0
-                    ? layer.thickness / totalThickness
-                    : (layers.length > 0 ? 1 / layers.length : 0);
-                addMaterialLeaf(layer.matId, weight);
-            }
-            return [...merged.values()];
+function resolveLeaves(read, defId, visited) {
+    while (true) {
+        if (visited.has(defId))
+            return [];
+        visited.add(defId);
+        const entity = read(defId);
+        if (!entity)
+            return [];
+        const typeUpper = entity.type.toUpperCase();
+        const attrs = entity.attributes || [];
+        if (typeUpper === 'IFCMATERIALLAYERSETUSAGE' || typeUpper === 'IFCMATERIALPROFILESETUSAGE') {
+            const next = getReference(attrs[0]);
+            if (next === undefined)
+                return [];
+            defId = next;
+            continue;
         }
-        case 'IFCMATERIALPROFILESET': {
-            // IfcMaterialProfileSet: [Name, Description, MaterialProfiles, CompositeProfile]
-            const profileIds = Array.isArray(attrs[2]) ? attrs[2].filter((id) => typeof id === 'number') : [];
-            const n = profileIds.length;
-            for (const profId of profileIds) {
-                const profRef = getRef(store, profId);
-                if (!profRef)
-                    continue;
-                const pa = extractor.extractEntity(profRef)?.attributes ?? [];
-                // IfcMaterialProfile: [Name, Description, Material, Profile, Priority, Category]
-                addMaterialLeaf(typeof pa[2] === 'number' ? pa[2] : undefined, n > 0 ? 1 / n : 0);
+        const merged = new Map();
+        const addMaterialLeaf = (matId, weight) => {
+            if (matId === undefined)
+                return;
+            const { name, category } = readMaterialNameCategory(read, matId);
+            mergeLeaves(merged, { id: matId, name, category, weight });
+        };
+        switch (typeUpper) {
+            case 'IFCMATERIAL':
+                return [{
+                        id: defId,
+                        name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
+                        category: typeof attrs[2] === 'string' ? attrs[2] : undefined,
+                        weight: 1,
+                    }];
+            case 'IFCMATERIALLAYERSET': {
+                // IfcMaterialLayerSet: [MaterialLayers, LayerSetName, Description]
+                const layerIds = getReferences(attrs[0]) ?? [];
+                const layers = [];
+                for (const layerId of layerIds) {
+                    const layerRef = read(layerId);
+                    if (!layerRef)
+                        continue;
+                    const la = layerRef.attributes ?? [];
+                    // IfcMaterialLayer: [Material, LayerThickness, IsVentilated, Name, Description, Category, Priority]
+                    layers.push({
+                        matId: getReference(la[0]),
+                        // Non-finite thickness would turn every weight into NaN
+                        // (Infinity/Infinity) - treat it as absent like <= 0.
+                        thickness: typeof la[1] === 'number' && Number.isFinite(la[1]) && la[1] > 0 ? la[1] : 0,
+                    });
+                }
+                const totalThickness = layers.reduce((s, l) => s + l.thickness, 0);
+                for (const layer of layers) {
+                    const weight = totalThickness > 0
+                        ? layer.thickness / totalThickness
+                        : (layers.length > 0 ? 1 / layers.length : 0);
+                    addMaterialLeaf(layer.matId, weight);
+                }
+                return [...merged.values()];
             }
-            return [...merged.values()];
-        }
-        case 'IFCMATERIALCONSTITUENTSET': {
-            // IfcMaterialConstituentSet: [Name, Description, MaterialConstituents]
-            const constIds = Array.isArray(attrs[2]) ? attrs[2].filter((id) => typeof id === 'number') : [];
-            const constituents = [];
-            for (const constId of constIds) {
-                const constRef = getRef(store, constId);
-                if (!constRef)
-                    continue;
-                const ca = extractor.extractEntity(constRef)?.attributes ?? [];
-                // IfcMaterialConstituent: [Name, Description, Material, Fraction, Category]
-                // An authored Fraction of 0 is preserved as 0 (an explicit
-                // "contributes nothing"), distinct from an ABSENT fraction.
-                constituents.push({
-                    matId: typeof ca[2] === 'number' ? ca[2] : undefined,
-                    // Non-finite (NaN/Infinity) and negative fractions are
-                    // malformed for an IfcNormalisedRatioMeasure — treat them
-                    // as unset so they can't poison the weight arithmetic
-                    // below. An authored 0.0 is legal and PRESERVED: it is an
-                    // explicit "contributes nothing", distinct from absent.
-                    fraction: typeof ca[3] === 'number' && Number.isFinite(ca[3]) && ca[3] >= 0 ? ca[3] : undefined,
-                });
+            case 'IFCMATERIALPROFILESET': {
+                // IfcMaterialProfileSet: [Name, Description, MaterialProfiles, CompositeProfile]
+                const profileIds = getReferences(attrs[2]) ?? [];
+                const n = profileIds.length;
+                for (const profId of profileIds) {
+                    const profRef = read(profId);
+                    if (!profRef)
+                        continue;
+                    const pa = profRef.attributes ?? [];
+                    // IfcMaterialProfile: [Name, Description, Material, Profile, Priority, Category]
+                    addMaterialLeaf(getReference(pa[2]), n > 0 ? 1 / n : 0);
+                }
+                return [...merged.values()];
             }
-            // Constituent Fraction is optional per-constituent. Constituents
-            // WITHOUT an explicit fraction share whatever remains of the whole
-            // (1 - sum of explicit) evenly, so they must not collapse to
-            // weight 0 and vanish from the totals. When the explicit fractions
-            // already fill (or overflow) the whole, each implicit sibling gets
-            // an even 1/n share instead so it still registers. The set is then
-            // renormalised to sum to exactly 1 (e.g. {1.0, unset} would
-            // otherwise weigh 1.5x the element), so the totals panel can never
-            // over-report an element's quantities. Explicit zeros survive all
-            // branches: an all-explicit-zero set keeps every weight at 0
-            // rather than inventing equal shares.
-            const explicitTotal = constituents.reduce((s, c) => s + (c.fraction ?? 0), 0);
-            const implicitCount = constituents.reduce((n, c) => n + (c.fraction === undefined ? 1 : 0), 0);
-            const remaining = 1 - explicitTotal;
-            const perImplicit = implicitCount > 0
-                ? (remaining > 0 ? remaining / implicitCount : 1 / constituents.length)
-                : 0;
-            const provisional = constituents.map((c) => c.fraction ?? perImplicit);
-            const totalWeight = provisional.reduce((s, w) => s + w, 0);
-            for (let i = 0; i < constituents.length; i++) {
-                // totalWeight can only be 0 when EVERY fraction is an authored
-                // 0.0 (absent fractions receive a positive share) — keep those
-                // explicit zeros instead of inventing equal weights.
-                const weight = totalWeight > 0 ? provisional[i] / totalWeight : 0;
-                addMaterialLeaf(constituents[i].matId, weight);
+            case 'IFCMATERIALCONSTITUENTSET': {
+                // IfcMaterialConstituentSet: [Name, Description, MaterialConstituents]
+                const constIds = getReferences(attrs[2]) ?? [];
+                const constituents = [];
+                for (const constId of constIds) {
+                    const constRef = read(constId);
+                    if (!constRef)
+                        continue;
+                    const ca = constRef.attributes ?? [];
+                    // IfcMaterialConstituent: [Name, Description, Material, Fraction, Category]
+                    // An authored Fraction of 0 is preserved as 0 (an explicit
+                    // "contributes nothing"), distinct from an ABSENT fraction.
+                    constituents.push({
+                        matId: getReference(ca[2]),
+                        // Non-finite (NaN/Infinity) and negative fractions are
+                        // malformed for an IfcNormalisedRatioMeasure — treat them
+                        // as unset so they can't poison the weight arithmetic
+                        // below. An authored 0.0 is legal and PRESERVED: it is an
+                        // explicit "contributes nothing", distinct from absent.
+                        fraction: typeof ca[3] === 'number' && Number.isFinite(ca[3]) && ca[3] >= 0 ? ca[3] : undefined,
+                    });
+                }
+                // Constituent Fraction is optional per-constituent. Constituents
+                // WITHOUT an explicit fraction share whatever remains of the whole
+                // (1 - sum of explicit) evenly, so they must not collapse to
+                // weight 0 and vanish from the totals. When the explicit fractions
+                // already fill (or overflow) the whole, each implicit sibling gets
+                // an even 1/n share instead so it still registers. The set is then
+                // renormalised to sum to exactly 1 (e.g. {1.0, unset} would
+                // otherwise weigh 1.5x the element), so the totals panel can never
+                // over-report an element's quantities. Explicit zeros survive all
+                // branches: an all-explicit-zero set keeps every weight at 0
+                // rather than inventing equal shares.
+                const explicitTotal = constituents.reduce((s, c) => s + (c.fraction ?? 0), 0);
+                const implicitCount = constituents.reduce((n, c) => n + (c.fraction === undefined ? 1 : 0), 0);
+                const remaining = 1 - explicitTotal;
+                const perImplicit = implicitCount > 0
+                    ? (remaining > 0 ? remaining / implicitCount : 1 / constituents.length)
+                    : 0;
+                const provisional = constituents.map((c) => c.fraction ?? perImplicit);
+                const totalWeight = provisional.reduce((s, w) => s + w, 0);
+                for (let i = 0; i < constituents.length; i++) {
+                    // totalWeight can only be 0 when EVERY fraction is an authored
+                    // 0.0 (absent fractions receive a positive share) — keep those
+                    // explicit zeros instead of inventing equal weights.
+                    const weight = totalWeight > 0 ? provisional[i] / totalWeight : 0;
+                    addMaterialLeaf(constituents[i].matId, weight);
+                }
+                return [...merged.values()];
             }
-            return [...merged.values()];
-        }
-        case 'IFCMATERIALLIST': {
-            // IfcMaterialList: [Materials]
-            const matIds = Array.isArray(attrs[0]) ? attrs[0].filter((id) => typeof id === 'number') : [];
-            const n = matIds.length;
-            for (const matId of matIds)
-                addMaterialLeaf(matId, n > 0 ? 1 / n : 0);
-            return [...merged.values()];
-        }
-        case 'IFCMATERIALLAYERSETUSAGE': {
-            const layerSetId = typeof attrs[0] === 'number' ? attrs[0] : undefined;
-            return layerSetId ? resolveLeaves(store, extractor, layerSetId, visited) : [];
-        }
-        case 'IFCMATERIALPROFILESETUSAGE': {
-            const profileSetId = typeof attrs[0] === 'number' ? attrs[0] : undefined;
-            return profileSetId ? resolveLeaves(store, extractor, profileSetId, visited) : [];
+            case 'IFCMATERIALLIST': {
+                // IfcMaterialList: [Materials]
+                const matIds = getReferences(attrs[0]) ?? [];
+                const n = matIds.length;
+                for (const matId of matIds)
+                    addMaterialLeaf(matId, n > 0 ? 1 / n : 0);
+                return [...merged.values()];
+            }
+            default:
+                // Unknown definition — treat as a single opaque material so it still
+                // appears in the tab and carries the element's full volume.
+                return [{
+                        id: defId,
+                        name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
+                        weight: 1,
+                    }];
         }
-        default:
-            // Unknown definition — treat as a single opaque material so it still
-            // appears in the tab and carries the element's full volume.
-            return [{
-                    id: defId,
-                    name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
-                    weight: 1,
-                }];
     }
 }
 const usageIndexCache = new WeakMap();
@@ -648,7 +433,12 @@ export function buildMaterialUsageIndex(store) {
 const displayCache = new WeakMap();
 /** Resolve a material entity's display name + IFC class for headers/labels.
  *  Memoised per (store, materialId) — callers resolve many materials in a loop. */
-export function getMaterialDisplay(store, materialId) {
+export function getMaterialDisplay(store, materialId, view) {
+    if (view) {
+        const record = materialRecordReader(store, view)(materialId);
+        return { name: typeof record?.attributes[0] === 'string' ? record.attributes[0] : `Material #${materialId}`,
+            type: record?.type ?? 'IfcMaterial' };
+    }
     let cache = displayCache.get(store);
     if (!cache) {
         cache = new Map();