@ifc-lite/parser 4.3.1 → 5.0.0

package/dist/quantity-collect.d.ts

@@ -0,0 +1,135 @@
+import type { EntityRef } from './types.js';
+import type { EntityExtractor } from './entity-extractor.js';
+import { type ProjectUnits } from './project-units.js';
+/** One extracted quantity, in the shape both call sites report. */
+export interface CollectedQuantity {
+    name: string;
+    type: number;
+    value: number;
+    /** SI factor of this quantity's explicit `Unit`, when it declares one.
+     *  An omitted unit inherits the project's unit assignment. */
+    explicitUnitSiScale?: number;
+}
+/**
+ * The part of `IfcDataStore` this walk needs, declared structurally so the
+ * module need not import `IfcDataStore` from `columnar-parser.ts`, which
+ * imports this file back.
+ */
+export interface QuantityLookupStore {
+    entityIndex: {
+        byId: {
+            get(id: number): EntityRef | undefined;
+        };
+    };
+    deferredEntityIndex?: {
+        get(id: number): EntityRef | undefined;
+    };
+}
+/**
+ * Read an `IfcElementQuantity.Quantities` list into flat quantity records.
+ *
+ * An `IfcPhysicalComplexQuantity` is skipped: it has no measure to report, and
+ * a `{name, type, value}` triple has nowhere to put its `HasQuantities`
+ * children. Before #3254 it fell through the simple-quantity path and surfaced
+ * as a phantom `Count = 0` — a row that satisfied IDS existence requirements,
+ * counted as "has quantities" in `validate`, entered the compare fingerprints
+ * and rendered as a bogus quantity card. Skipping matches what the legacy
+ * `quantity-extractor.ts` already does for a type it does not recognise, so all
+ * three quantity readers now agree.
+ *
+ * **Its nested quantities are dropped with it, and that is a known gap with no
+ * tracking issue behind it.** Not "tracked separately" — an earlier version of
+ * this comment said so and nothing tracked it. The children are lost in every
+ * case — #3254's fixture nests two `IfcQuantityArea` totalling 26 m² that read
+ * back as nothing — and a set whose ONLY member is a complex quantity collects
+ * nothing, so since #3261 {@link readQuantitySet} drops the whole
+ * `IfcElementQuantity` rather than reporting an empty one.
+ *
+ * The gap is deliberate rather than overlooked. Flattening the children into
+ * this list would feed new names to a dozen name-keyed consumers, and — via the
+ * mutable property view that re-writes a touched `IfcElementQuantity` from these
+ * records, and `step-property-sets.ts` which emits them as flat siblings — would
+ * permanently destroy the complex structure on the next export. Surfacing them
+ * safely needs a representation these records do not have: one that read-side
+ * consumers can see and the write-back path provably skips. Until that exists,
+ * under-reporting is the lesser harm, and this paragraph is the whole of what
+ * anyone is doing about it.
+ *
+ * An entity of a type absent from {@link QUANTITY_TYPE_MAP} still reports as a
+ * `Count`, keeping its value under a wrong label rather than vanishing. No
+ * `IfcPhysicalSimpleQuantity` subtype relies on that fallback today —
+ * `IfcQuantityNumber` (IFC4X3) did until #3266 gave it `QuantityType.Number`,
+ * and `test/quantity-type-map-coverage.test.ts` now reds if a schema declares a
+ * subtype the map has not gained. That test guards the OTHER hand-written set
+ * too: `PROPERTY_ENTITY_TYPES` in `columnar-parser-indexes.ts` decides whether
+ * the entity is retained at all, so a subtype missing THERE never reaches this
+ * map and the quantity does not exist rather than being mislabelled.
+ */
+export declare function collectQuantitiesFromRefs(store: QuantityLookupStore, extractor: EntityExtractor, refs: unknown): CollectedQuantity[];
+/** One extracted quantity set, in the shape both call sites report. */
+export interface CollectedQuantitySet {
+    name: string;
+    /** `GlobalId` of the source `IfcElementQuantity` instance, when read as a string. */
+    globalId?: string;
+    quantities: CollectedQuantity[];
+}
+/**
+ * Read one `IfcElementQuantity` into a reportable quantity set, or `null` when
+ * it carries nothing worth reporting.
+ *
+ * `IFC4_ADD2_TC1.exp` (identically `IFC4X3.exp`):
+ *
+ *     ENTITY IfcElementQuantity
+ *      SUBTYPE OF (IfcQuantitySet);
+ *         MethodOfMeasurement : OPTIONAL IfcLabel;
+ *         Quantities : SET [1:?] OF IfcPhysicalQuantity;
+ *
+ * `SET [1:?]` admits no empty set, so a set that walks to zero quantities —
+ * written empty, or filled only with members this reader cannot report, such as
+ * an unresolvable reference, an `IfcPhysicalComplexQuantity` (#3254), or a
+ * measure outside the IEEE-754 double range — is non-conformant data. Reporting it anyway would assert "this element has
+ * quantities" on the strength of a name alone, and the consumers act on exactly
+ * that: `validate` counts the element as quantified in its quantity-completeness
+ * figure, an IDS quantity-set existence check passes, and the viewer's fallback
+ * to the element's TYPE quantities is suppressed by the phantom occurrence set,
+ * hiding the real numbers the type carries. So it is dropped (#3259).
+ *
+ * That applies unchanged when every member was dropped for being
+ * unrepresentable: the set then vanishes rather than surviving empty. Keeping
+ * an empty shell would make exactly the claim #3259 removed — "this element is
+ * quantified" — while carrying no number to back it, and it would still
+ * suppress the type-quantity fallback. The reason each quantity went is on the
+ * console; the reason the set went is that nothing in it survived.
+ *
+ * The instance path and the type path both go through here, so the drop cannot
+ * come apart between them again: it used to be inlined at each site, and the
+ * type site dropped while the instance site kept.
+ */
+export declare function readQuantitySet(store: QuantityLookupStore, extractor: EntityExtractor, qsetRef: EntityRef): CollectedQuantitySet | null;
+/**
+ * SI scale factor for a `Qto_` value, preferring its explicit `Unit` and then
+ * resolving against the project's declared units.
+ *
+ * An `IfcQuantityLength`/`Area`/`Volume` is stored in the project's raw
+ * author unit exactly like an `IfcPropertySingleValue` of the matching
+ * measure type — the value is not pre-converted to SI by the exporter. A
+ * consumer that hashes or otherwise compares `CollectedQuantity.value`
+ * across two files (or against a base-SI literal) as-is therefore reads a
+ * project's choice of length unit as a change in the design itself: the
+ * same 2 m wall authored in millimetres carries the raw value `2000`
+ * instead of `2`.
+ *
+ * `1` for `Count`/`Weight`/`Time`/`Number` — this only scales the three
+ * quantity types that are themselves `IfcLengthMeasure`-family measures.
+ *
+ * Area and Volume scale by the SQUARE and CUBE of the length factor (a
+ * millimetre-authored 1 m² is stored as `1e6`, not `1e3`) — but only as a
+ * FALLBACK: `IFC` lets a project declare an explicit `AREAUNIT`/`VOLUMEUNIT`
+ * with no arithmetic relationship to `LENGTHUNIT`, so the file's own
+ * declaration is preferred and the length-derived power is used only when
+ * the project declares none. An explicit member `Unit` always wins; IFC uses
+ * it specifically to let a quantity depart from its containing project's
+ * assignment.
+ */
+export declare function quantitySiScale(quantity: CollectedQuantity, units: ProjectUnits): number;
+//# sourceMappingURL=quantity-collect.d.ts.map

package/dist/quantity-collect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantity-collect.d.ts","sourceRoot":"","sources":["../src/quantity-collect.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAG7D,OAAO,EAAoB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEzE,mEAAmE;AACnE,MAAM,WAAW,iBAAiB;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd;kEAC8D;IAC9D,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAChC,WAAW,EAAE;QAAE,IAAI,EAAE;YAAE,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAA;SAAE,CAAA;KAAE,CAAC;IAClE,mBAAmB,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAA;KAAE,CAAC;CACpE;AA2BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,yBAAyB,CACrC,KAAK,EAAE,mBAAmB,EAC1B,SAAS,EAAE,eAAe,EAC1B,IAAI,EAAE,OAAO,GACd,iBAAiB,EAAE,CA2ErB;AAUD,uEAAuE;AACvE,MAAM,WAAW,oBAAoB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,qFAAqF;IACrF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,iBAAiB,EAAE,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,eAAe,CAC3B,KAAK,EAAE,mBAAmB,EAC1B,SAAS,EAAE,eAAe,EAC1B,OAAO,EAAE,SAAS,GACnB,oBAAoB,GAAG,IAAI,CAe7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,iBAAiB,EAAE,KAAK,EAAE,YAAY,GAAG,MAAM,CAqBxF"}

package/dist/quantity-collect.js

@@ -0,0 +1,253 @@
+/* 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/. */
+/**
+ * Shared reader for an `IfcElementQuantity.Quantities` list (#3254).
+ *
+ * The instance path (`ColumnarParser.extractQuantitiesOnDemand`) and the type
+ * path (`extractQsetsFromIds`) both walk that list, and each used to inline its
+ * own copy of the walk — two copies that would disagree the moment either was
+ * touched. The walk lives here and both call it.
+ */
+import { QuantityType } from '@ifc-lite/data';
+import { QUANTITY_TYPE_MAP } from './columnar-parser-indexes.js';
+import { isUnrepresentableNumericValue } from './attribute-helpers.js';
+import { resolveUnitByRef } from './project-units.js';
+/**
+ * `IfcPhysicalComplexQuantity` groups other quantities instead of carrying a
+ * value of its own (`packages/codegen/schemas/IFC4_ADD2_TC1.exp`, identically
+ * in `IFC4X3.exp`):
+ *
+ *     ENTITY IfcPhysicalComplexQuantity
+ *      SUBTYPE OF (IfcPhysicalQuantity);
+ *         HasQuantities : SET [1:?] OF IfcPhysicalQuantity;
+ *         Discrimination : IfcLabel;
+ *         Quality : OPTIONAL IfcLabel;
+ *         Usage : OPTIONAL IfcLabel;
+ *
+ * With `Name` and `Description` inherited from `IfcPhysicalQuantity`, the
+ * flattened slots are HasQuantities[2], Discrimination[3], Quality[4],
+ * Usage[5]. Slot 3 — where every `IfcPhysicalSimpleQuantity` subtype keeps its
+ * measure — therefore holds a label here.
+ */
+const COMPLEX_QUANTITY_TYPE = 'IFCPHYSICALCOMPLEXQUANTITY';
+/**
+ * Value slot on every `IfcPhysicalSimpleQuantity` subtype: Name[0],
+ * Description[1], Unit[2], *Value[3].
+ */
+const SIMPLE_QUANTITY_VALUE_SLOT = 3;
+/**
+ * Read an `IfcElementQuantity.Quantities` list into flat quantity records.
+ *
+ * An `IfcPhysicalComplexQuantity` is skipped: it has no measure to report, and
+ * a `{name, type, value}` triple has nowhere to put its `HasQuantities`
+ * children. Before #3254 it fell through the simple-quantity path and surfaced
+ * as a phantom `Count = 0` — a row that satisfied IDS existence requirements,
+ * counted as "has quantities" in `validate`, entered the compare fingerprints
+ * and rendered as a bogus quantity card. Skipping matches what the legacy
+ * `quantity-extractor.ts` already does for a type it does not recognise, so all
+ * three quantity readers now agree.
+ *
+ * **Its nested quantities are dropped with it, and that is a known gap with no
+ * tracking issue behind it.** Not "tracked separately" — an earlier version of
+ * this comment said so and nothing tracked it. The children are lost in every
+ * case — #3254's fixture nests two `IfcQuantityArea` totalling 26 m² that read
+ * back as nothing — and a set whose ONLY member is a complex quantity collects
+ * nothing, so since #3261 {@link readQuantitySet} drops the whole
+ * `IfcElementQuantity` rather than reporting an empty one.
+ *
+ * The gap is deliberate rather than overlooked. Flattening the children into
+ * this list would feed new names to a dozen name-keyed consumers, and — via the
+ * mutable property view that re-writes a touched `IfcElementQuantity` from these
+ * records, and `step-property-sets.ts` which emits them as flat siblings — would
+ * permanently destroy the complex structure on the next export. Surfacing them
+ * safely needs a representation these records do not have: one that read-side
+ * consumers can see and the write-back path provably skips. Until that exists,
+ * under-reporting is the lesser harm, and this paragraph is the whole of what
+ * anyone is doing about it.
+ *
+ * An entity of a type absent from {@link QUANTITY_TYPE_MAP} still reports as a
+ * `Count`, keeping its value under a wrong label rather than vanishing. No
+ * `IfcPhysicalSimpleQuantity` subtype relies on that fallback today —
+ * `IfcQuantityNumber` (IFC4X3) did until #3266 gave it `QuantityType.Number`,
+ * and `test/quantity-type-map-coverage.test.ts` now reds if a schema declares a
+ * subtype the map has not gained. That test guards the OTHER hand-written set
+ * too: `PROPERTY_ENTITY_TYPES` in `columnar-parser-indexes.ts` decides whether
+ * the entity is retained at all, so a subtype missing THERE never reaches this
+ * map and the quantity does not exist rather than being mislabelled.
+ */
+export function collectQuantitiesFromRefs(store, extractor, refs) {
+    const quantities = [];
+    if (!Array.isArray(refs))
+        return quantities;
+    for (const qtyRef of refs) {
+        if (typeof qtyRef !== 'number')
+            continue;
+        const qtyEntityRef = store.entityIndex.byId.get(qtyRef) ?? store.deferredEntityIndex?.get(qtyRef);
+        if (!qtyEntityRef)
+            continue;
+        const qtyEntity = extractor.extractEntity(qtyEntityRef);
+        if (!qtyEntity)
+            continue;
+        const qtyTypeUpper = qtyEntity.type.toUpperCase();
+        if (qtyTypeUpper === COMPLEX_QUANTITY_TYPE)
+            continue;
+        const qtyAttrs = qtyEntity.attributes || [];
+        const qtyName = typeof qtyAttrs[0] === 'string' ? qtyAttrs[0] : '';
+        if (!qtyName)
+            continue;
+        const qtyType = QUANTITY_TYPE_MAP[qtyTypeUpper] ?? QuantityType.Count;
+        // `IfcPhysicalSimpleQuantity.Unit` is optional, but it overrides the
+        // project assignment when present. Preserve its scale on the record so
+        // every downstream reader of this shared collection uses the same
+        // physical value rather than silently treating (say) 2000 mm as 2000 m.
+        const unitRef = qtyAttrs[2];
+        const unit = typeof unitRef === 'number'
+            ? resolveUnitByRef(extractor, store.entityIndex, unitRef)
+            : null;
+        const rawValue = qtyAttrs[SIMPLE_QUANTITY_VALUE_SLOT];
+        // A measure the double range cannot hold is dropped with a diagnostic,
+        // not reported as `0`. `CollectedQuantity.value` is `number` and is
+        // consumed by callers that do arithmetic on it, so there is no
+        // in-band way to say "unrepresentable" — and `0` is the worst of the
+        // available lies, because a 0 m^3 volume reads as a measurement
+        // somebody took. An absent quantity is detectable; a zero one is not.
+        //
+        // This matches what the sibling path already does:
+        // `QuantityExtractor.extractQuantity` returns `null` and warns when
+        // slot 3 is not a number. That path and this one walk the same
+        // `Quantities` list, so they must agree.
+        //
+        // The diagnostic is per occurrence, deliberately. Each line names a
+        // different entity id and quantity name, so it is the list of what was
+        // dropped rather than one message repeated — collapsing it to
+        // once-per-file would leave a reader knowing that something was
+        // discarded and not which. There is also no per-file context threaded
+        // through this function to hang a once-per-file flag on: the only
+        // place to keep one is module scope, which outlives a file in the
+        // viewer's long-lived worker and would then silence the *next* file's
+        // first warning. No `console.warn` in this package is throttled
+        // today, so a local cap here would be the one-off. The cost is bounded by how
+        // corrupt the file is, and a file with thousands of unrepresentable
+        // measures has a louder problem than its console output.
+        if (isUnrepresentableNumericValue(rawValue)) {
+            console.warn(`[quantity-collect] ${qtyEntity.type} #${qtyEntity.expressId} "${qtyName}" ` +
+                `has a value outside the IEEE-754 double range (${String(rawValue)}); ` +
+                `dropping the quantity rather than reporting it as 0.`);
+            continue;
+        }
+        const value = typeof rawValue === 'number' ? rawValue : 0;
+        quantities.push({
+            name: qtyName,
+            type: qtyType,
+            value,
+            ...(unit ? { explicitUnitSiScale: unit.resolved.siScale } : {}),
+        });
+    }
+    return quantities;
+}
+/**
+ * `Quantities` slot on `IfcElementQuantity`: GlobalId[0], OwnerHistory[1],
+ * Name[2], Description[3] inherited from `IfcRoot`, then MethodOfMeasurement[4]
+ * and Quantities[5]. GlobalId[0] is the identity of the `IfcElementQuantity`
+ * instance itself, not any of its quantities.
+ */
+const QUANTITIES_SLOT = 5;
+/**
+ * Read one `IfcElementQuantity` into a reportable quantity set, or `null` when
+ * it carries nothing worth reporting.
+ *
+ * `IFC4_ADD2_TC1.exp` (identically `IFC4X3.exp`):
+ *
+ *     ENTITY IfcElementQuantity
+ *      SUBTYPE OF (IfcQuantitySet);
+ *         MethodOfMeasurement : OPTIONAL IfcLabel;
+ *         Quantities : SET [1:?] OF IfcPhysicalQuantity;
+ *
+ * `SET [1:?]` admits no empty set, so a set that walks to zero quantities —
+ * written empty, or filled only with members this reader cannot report, such as
+ * an unresolvable reference, an `IfcPhysicalComplexQuantity` (#3254), or a
+ * measure outside the IEEE-754 double range — is non-conformant data. Reporting it anyway would assert "this element has
+ * quantities" on the strength of a name alone, and the consumers act on exactly
+ * that: `validate` counts the element as quantified in its quantity-completeness
+ * figure, an IDS quantity-set existence check passes, and the viewer's fallback
+ * to the element's TYPE quantities is suppressed by the phantom occurrence set,
+ * hiding the real numbers the type carries. So it is dropped (#3259).
+ *
+ * That applies unchanged when every member was dropped for being
+ * unrepresentable: the set then vanishes rather than surviving empty. Keeping
+ * an empty shell would make exactly the claim #3259 removed — "this element is
+ * quantified" — while carrying no number to back it, and it would still
+ * suppress the type-quantity fallback. The reason each quantity went is on the
+ * console; the reason the set went is that nothing in it survived.
+ *
+ * The instance path and the type path both go through here, so the drop cannot
+ * come apart between them again: it used to be inlined at each site, and the
+ * type site dropped while the instance site kept.
+ */
+export function readQuantitySet(store, extractor, qsetRef) {
+    const qsetEntity = extractor.extractEntity(qsetRef);
+    if (!qsetEntity)
+        return null;
+    const qsetAttrs = qsetEntity.attributes || [];
+    // Left empty rather than a fabricated `QuantitySet #<id>` when the source
+    // declared no Name: this is `store.getQuantities()`'s answer, consumed
+    // verbatim downstream (MCP tool responses, `bim.quantities()`) as though
+    // the model had genuinely declared that name (#3530 census).
+    const qsetName = typeof qsetAttrs[2] === 'string' ? qsetAttrs[2] : '';
+    const qsetGlobalId = typeof qsetAttrs[0] === 'string' ? qsetAttrs[0] : undefined;
+    const quantities = collectQuantitiesFromRefs(store, extractor, qsetAttrs[QUANTITIES_SLOT]);
+    if (quantities.length === 0)
+        return null;
+    return { name: qsetName, globalId: qsetGlobalId, quantities };
+}
+/**
+ * SI scale factor for a `Qto_` value, preferring its explicit `Unit` and then
+ * resolving against the project's declared units.
+ *
+ * An `IfcQuantityLength`/`Area`/`Volume` is stored in the project's raw
+ * author unit exactly like an `IfcPropertySingleValue` of the matching
+ * measure type — the value is not pre-converted to SI by the exporter. A
+ * consumer that hashes or otherwise compares `CollectedQuantity.value`
+ * across two files (or against a base-SI literal) as-is therefore reads a
+ * project's choice of length unit as a change in the design itself: the
+ * same 2 m wall authored in millimetres carries the raw value `2000`
+ * instead of `2`.
+ *
+ * `1` for `Count`/`Weight`/`Time`/`Number` — this only scales the three
+ * quantity types that are themselves `IfcLengthMeasure`-family measures.
+ *
+ * Area and Volume scale by the SQUARE and CUBE of the length factor (a
+ * millimetre-authored 1 m² is stored as `1e6`, not `1e3`) — but only as a
+ * FALLBACK: `IFC` lets a project declare an explicit `AREAUNIT`/`VOLUMEUNIT`
+ * with no arithmetic relationship to `LENGTHUNIT`, so the file's own
+ * declaration is preferred and the length-derived power is used only when
+ * the project declares none. An explicit member `Unit` always wins; IFC uses
+ * it specifically to let a quantity depart from its containing project's
+ * assignment.
+ */
+export function quantitySiScale(quantity, units) {
+    if (quantity.explicitUnitSiScale !== undefined)
+        return quantity.explicitUnitSiScale;
+    switch (quantity.type) {
+        case QuantityType.Length:
+            return units.unitForMeasure('IfcLengthMeasure')?.siScale ?? 1;
+        case QuantityType.Area: {
+            const explicit = units.resolvedForUnitType('AREAUNIT')?.siScale;
+            if (explicit !== undefined)
+                return explicit;
+            const length = units.unitForMeasure('IfcLengthMeasure')?.siScale ?? 1;
+            return length ** 2;
+        }
+        case QuantityType.Volume: {
+            const explicit = units.resolvedForUnitType('VOLUMEUNIT')?.siScale;
+            if (explicit !== undefined)
+                return explicit;
+            const length = units.unitForMeasure('IfcLengthMeasure')?.siScale ?? 1;
+            return length ** 3;
+        }
+        default:
+            return 1;
+    }
+}
+//# sourceMappingURL=quantity-collect.js.map

package/dist/quantity-collect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantity-collect.js","sourceRoot":"","sources":["../src/quantity-collect.ts"],"names":[],"mappings":"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"}

package/dist/query-backend-maps.d.ts

@@ -14,19 +14,16 @@
 import { RelationshipType } from '@ifc-lite/data';
 /**
  * IFC4 subtype map — parent types to their StandardCase/ElementedCase
- * subtypes. In IFC4 many element types have `*StandardCase` subtypes that the
- * parser stores under the full type name, so `byType('IfcWall')` has to look
- * for `IfcWallStandardCase` as well to answer what the caller meant.
+ * subtypes, kept for backward compatibility (`@ifc-lite/cli`'s
+ * `validate-subtypes.test.ts` reads this table directly as ground truth) and
+ * as a fixed, hand-legible cross-check of the schema-driven expansion below.
+ * `expandTypes` no longer walks this table itself — see its doc comment.
  *
  * Keys and values are UPPERCASE because `entityIndex.byType` is keyed by the
  * raw STEP type name (e.g. `IFCWALLSTANDARDCASE`).
  */
 export declare const IFC_SUBTYPES: Record<string, string[]>;
-/**
- * Expand a caller's type list to include the known IFC subtypes, uppercasing
- * PascalCase input (`'IfcWall'`) for the `entityIndex` lookup.
- */
-export declare function expandTypes(types: string[]): string[];
+export declare function expandTypes(types: string[], schemaVersion?: string): string[];
 /**
  * Relationship names the SDK's `related(ref, relType, direction)` accepts,
  * keyed in the PascalCase spelling a caller writes.

package/dist/query-backend-maps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-backend-maps.d.ts","sourceRoot":"","sources":["../src/query-backend-maps.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAUjD,CAAC;AAEF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAWrD;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAM/D,CAAC"}
+{"version":3,"file":"query-backend-maps.d.ts","sourceRoot":"","sources":["../src/query-backend-maps.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,gBAAgB,EAAgC,MAAM,gBAAgB,CAAC;AAGhF;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAcjD,CAAC;AAkHF,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ7E;AAiDD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAM/D,CAAC"}

package/dist/query-backend-maps.js

@@ -14,12 +14,14 @@
  * many, so the tables live here, next to the `entityIndex` whose key shape
  * they are written against.
  */
-import { RelationshipType } from '@ifc-lite/data';
+import { RelationshipType, expandTypeNamesToDescendants } from '@ifc-lite/data';
+import { getInheritanceChain, isQueryableObjectType } from './ifc-schema.js';
 /**
  * IFC4 subtype map — parent types to their StandardCase/ElementedCase
- * subtypes. In IFC4 many element types have `*StandardCase` subtypes that the
- * parser stores under the full type name, so `byType('IfcWall')` has to look
- * for `IfcWallStandardCase` as well to answer what the caller meant.
+ * subtypes, kept for backward compatibility (`@ifc-lite/cli`'s
+ * `validate-subtypes.test.ts` reads this table directly as ground truth) and
+ * as a fixed, hand-legible cross-check of the schema-driven expansion below.
+ * `expandTypes` no longer walks this table itself — see its doc comment.
  *
  * Keys and values are UPPERCASE because `entityIndex.byType` is keyed by the
  * raw STEP type name (e.g. `IFCWALLSTANDARDCASE`).
@@ -34,23 +36,165 @@ export const IFC_SUBTYPES = {
     IFCMEMBER: ['IFCMEMBERSTANDARDCASE'],
     IFCPLATE: ['IFCPLATESTANDARDCASE'],
     IFCOPENINGELEMENT: ['IFCOPENINGSTANDARDCASE'],
+    // Not a `*StandardCase` family, and absent until #3229: IFC4 exporters write
+    // furniture as IFCFURNITURE, so `byType('IfcFurnishingElement')` answered
+    // with nothing on a model that plainly contained furniture.
+    IFCFURNISHINGELEMENT: ['IFCFURNITURE', 'IFCSYSTEMFURNITUREELEMENT'],
 };
+// Cached per name: `rootBranchOf` and `isQueryableObjectType` both walk the
+// inheritance chain, and the gate calls one of them once per descendant. On
+// `byType('IfcRoot')` that is 294 uncached walks for one query.
+const rootBranchCache = new Map();
 /**
- * Expand a caller's type list to include the known IFC subtypes, uppercasing
- * PascalCase input (`'IfcWall'`) for the `entityIndex` lookup.
+ * Bound on both memos below. Their keys are caller-supplied type names and
+ * type lists, and `byType()` is reached from the MCP server and the viewer,
+ * long-lived processes where those come from an agent or an SDK script — so
+ * an unbounded map grows on typos and vendor namespaces for the life of the
+ * process. Clearing wholesale costs one recompute and needs no bookkeeping;
+ * the bundled schemas declare ~1160 names, so a real workload never reaches
+ * it.
  */
-export function expandTypes(types) {
-    const result = [];
+const CACHE_LIMIT = 4096;
+function rootBranchOf(type) {
+    const cached = rootBranchCache.get(type);
+    if (cached !== undefined)
+        return cached;
+    const branch = computeRootBranch(type);
+    if (rootBranchCache.size >= CACHE_LIMIT)
+        rootBranchCache.clear();
+    rootBranchCache.set(type, branch);
+    return branch;
+}
+function computeRootBranch(type) {
+    const chain = getInheritanceChain(type);
+    if (chain.includes('IfcRelationship'))
+        return 'relationship';
+    if (chain.includes('IfcPropertyDefinition'))
+        return 'propertyDefinition';
+    if (chain.includes('IfcTypeObject'))
+        return 'typeObject';
+    if (chain.includes('IfcObjectDefinition'))
+        return 'object';
+    return 'other';
+}
+/**
+ * Expand a caller's type list to every schema-declared descendant (itself
+ * plus every type that has it as an ancestor, direct or indirect), so
+ * `byType('IfcBuildingElement')` finds the concrete leaves a model actually
+ * contains instead of matching nothing — `IfcBuildingElement`/`IfcElement`
+ * are abstract EXPRESS supertypes, never a literal STEP entity type, so a
+ * caller asking for one always meant its subtypes.
+ *
+ * Delegates to `@ifc-lite/data`'s `expandTypeNamesToDescendants`, the single
+ * schema-authority resolver every `byType()` backend now shares — this used
+ * to be a fixed nine-entry `IFC_SUBTYPES` table (still above, unused here)
+ * that only aliased `*StandardCase`/`*ElementedCase` pairs and silently
+ * dropped every abstract-supertype query.
+ *
+ * PASS `schemaVersion`. It is the queried model's own `store.schemaVersion`,
+ * and it is what makes the answer exact. Descendant sets are not the same
+ * across versions -- buildingSMART re-parented entities, so
+ * `IfcReinforcingBar` is an `IfcBuildingElement` in IFC2X3 and an
+ * `IfcElementComponent` in IFC4 -- while the names a FILE contains need not
+ * belong to the version its header claims. The resolver reconciles the two;
+ * see its module doc for the exact rule.
+ *
+ * It is optional only because this function is a published export of
+ * `@ifc-lite/parser` and of `@ifc-lite/mcp/browser`, and requiring it would
+ * stop an existing `expandTypes(['IfcWall'])` compiling -- a major, which a
+ * bug-fix release is not. Omitted, the expansion falls back to the UNION
+ * across the three bundled schemas: a superset that finds every spelling but
+ * cannot tell a re-parented entity from a real subtype, so
+ * `expandTypes(['IfcBuildingElement'])` answers with reinforcing bars that
+ * `expandTypes(['IfcBuildingElement'], 'IFC4')` correctly leaves out. Every
+ * caller in this repository passes the version; a viewer test goes red if one
+ * stops.
+ *
+ * The expansion does not cross an `IfcRoot` branch. Descending the whole
+ * hierarchy from an abstract root turned `byType('IfcRoot')` into "every
+ * rooted record in the file" — 223 rows on `infra-bridge.ifc`, 36 of them
+ * `IfcRelDefinesByProperties` — which a caller then hands to `storey()` or
+ * `group_by`, written against products. `IfcObjectDefinition` swept in every
+ * `*Type` the same way, contradicting the untyped branch of the very same
+ * backends, which has always answered with {@link isQueryableObjectType}
+ * only.
+ *
+ * The gate reads the requested type's branch rather than "is a product",
+ * because `byType('IfcBuildingElementType')` means its subtypes exactly as
+ * much as `byType('IfcBuildingElement')` does. The requested names themselves
+ * are never gated: a caller who spells out `IfcPropertySet` said what they
+ * wanted.
+ *
+ * Memoized on (schemaVersion, type list). Every `byType()` call goes through
+ * here, and `validate` now calls it twice per store; the closure plus the gate
+ * cost 0.78 ms for `IfcRoot` on IFC4, which the caches take to a Map lookup.
+ * The key keeps the caller's order rather than sorting it: the output order is
+ * contractual — each requested type ahead of its own descendants — so two
+ * different orders are two different answers and must not share an entry.
+ */
+const expandCache = new Map();
+/**
+ * Cache-key stand-in for an omitted version. Not a value `resolveSchemaVersion`
+ * can ever see, so the union answer cannot share an entry with `''` or any
+ * other unrecognized string, which resolve to IFC4 instead.
+ */
+const NO_VERSION_KEY = '\u0001union';
+export function expandTypes(types, schemaVersion) {
+    const key = `${schemaVersion ?? NO_VERSION_KEY}\u0000${types.join('\u0000')}`;
+    const cached = expandCache.get(key);
+    if (cached)
+        return [...cached];
+    const result = computeExpandTypes(types, schemaVersion);
+    if (expandCache.size >= CACHE_LIMIT)
+        expandCache.clear();
+    expandCache.set(key, result);
+    return [...result];
+}
+/** The three versions with a bundled table, for the no-version union. */
+const UNION_VERSIONS = ['IFC2X3', 'IFC4', 'IFC4X3'];
+/**
+ * One type's expansion when the caller named no schema: the requested type,
+ * then every descendant ANY bundled schema gives it, sorted.
+ *
+ * Deliberately a superset rather than a guess at a version. A caller who has
+ * not said which schema the file is written in is better served finding a
+ * record that is arguably of the wrong class than silently finding none at
+ * all, which is what picking one table for them would do to the other two.
+ * The sort keeps the order stable across schema-table regeneration, as the
+ * per-version path does.
+ */
+function unionExpansion(type) {
+    const self = expandTypeNamesToDescendants([type], UNION_VERSIONS[0])[0];
+    const rest = new Set();
+    for (const version of UNION_VERSIONS) {
+        const expanded = expandTypeNamesToDescendants([type], version);
+        for (let i = 1; i < expanded.length; i++)
+            rest.add(expanded[i]);
+    }
+    rest.delete(self);
+    return [self, ...[...rest].sort()];
+}
+function computeExpandTypes(types, schemaVersion) {
+    const out = [];
+    const seen = new Set();
     for (const type of types) {
-        const upper = type.toUpperCase();
-        result.push(upper);
-        const subtypes = IFC_SUBTYPES[upper];
-        if (subtypes) {
-            for (const sub of subtypes)
-                result.push(sub);
+        const branch = rootBranchOf(type);
+        const expanded = schemaVersion === undefined
+            ? unionExpansion(type)
+            : expandTypeNamesToDescendants([type], schemaVersion);
+        for (let i = 0; i < expanded.length; i++) {
+            const name = expanded[i];
+            // Index 0 is the requested type itself, which is never gated: a caller
+            // who spells out `IfcPropertySet` said what they wanted.
+            if (i > 0 && !isQueryableObjectType(name) && rootBranchOf(name) !== branch)
+                continue;
+            if (seen.has(name))
+                continue;
+            seen.add(name);
+            out.push(name);
         }
     }
-    return result;
+    return out;
 }
 /**
  * Relationship names the SDK's `related(ref, relType, direction)` accepts,

package/dist/query-backend-maps.js.map

@@ -1 +1 @@
-{"version":3,"file":"query-backend-maps.js","sourceRoot":"","sources":["../src/query-backend-maps.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,YAAY,GAA6B;IACpD,OAAO,EAAE,CAAC,qBAAqB,EAAE,sBAAsB,CAAC;IACxD,OAAO,EAAE,CAAC,qBAAqB,CAAC;IAChC,SAAS,EAAE,CAAC,uBAAuB,CAAC;IACpC,OAAO,EAAE,CAAC,qBAAqB,CAAC;IAChC,SAAS,EAAE,CAAC,uBAAuB,CAAC;IACpC,OAAO,EAAE,CAAC,qBAAqB,EAAE,sBAAsB,CAAC;IACxD,SAAS,EAAE,CAAC,uBAAuB,CAAC;IACpC,QAAQ,EAAE,CAAC,sBAAsB,CAAC;IAClC,iBAAiB,EAAE,CAAC,wBAAwB,CAAC;CAC9C,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,KAAe;IACzC,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACjC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACnB,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,QAAQ,EAAE,CAAC;YACb,KAAK,MAAM,GAAG,IAAI,QAAQ;gBAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAqC;IAClE,iCAAiC,EAAE,gBAAgB,CAAC,gBAAgB;IACpE,gBAAgB,EAAE,gBAAgB,CAAC,UAAU;IAC7C,mBAAmB,EAAE,gBAAgB,CAAC,aAAa;IACnD,kBAAkB,EAAE,gBAAgB,CAAC,YAAY;IACjD,kBAAkB,EAAE,gBAAgB,CAAC,YAAY;CAClD,CAAC"}
+{"version":3,"file":"query-backend-maps.js","sourceRoot":"","sources":["../src/query-backend-maps.ts"],"names":[],"mappings":"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"}

package/dist/relationship-extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relationship-extractor.d.ts","sourceRoot":"","sources":["../src/relationship-extractor.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1D,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAyB;gBAE7B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC;IAI5C;;OAEG;IACG,yBAAyB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IA6B1D;;OAEG;IACH,oBAAoB,IAAI,YAAY,EAAE;IAsBtC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAwD3B,OAAO,CAAC,iBAAiB;CAM1B"}
+{"version":3,"file":"relationship-extractor.d.ts","sourceRoot":"","sources":["../src/relationship-extractor.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1D,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAyB;gBAE7B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC;IAI5C;;OAEG;IACG,yBAAyB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IA6B1D;;OAEG;IACH,oBAAoB,IAAI,YAAY,EAAE;IAsBtC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAyE3B,OAAO,CAAC,iBAAiB;CAM1B"}