LTplus-AG
diff --git a/‎.changeset/supertype-descendant-resolver.md‎
Lines changed: 25 additions & 0 deletions b/‎.changeset/supertype-descendant-resolver.md‎
Lines changed: 25 additions & 0 deletions
diff --git a/‎apps/viewer/src/sdk/adapters/query-adapter.supertype-descendants.test.ts‎
Lines changed: 126 additions & 0 deletions b/‎apps/viewer/src/sdk/adapters/query-adapter.supertype-descendants.test.ts‎
Lines changed: 126 additions & 0 deletions
diff --git a/‎apps/viewer/src/sdk/adapters/query-adapter.ts‎
Lines changed: 8 additions & 2 deletions b/‎apps/viewer/src/sdk/adapters/query-adapter.ts‎
Lines changed: 8 additions & 2 deletions
diff --git a/‎packages/cli/src/commands/validate-subtypes.test.ts‎
Lines changed: 81 additions & 5 deletions b/‎packages/cli/src/commands/validate-subtypes.test.ts‎
Lines changed: 81 additions & 5 deletions
diff --git a/‎packages/cli/src/commands/validate.ts‎
Lines changed: 11 additions & 6 deletions b/‎packages/cli/src/commands/validate.ts‎
Lines changed: 11 additions & 6 deletions
@@ -0,0 +1,25 @@
+---
+'@ifc-lite/data': minor
+'@ifc-lite/parser': minor
+'@ifc-lite/cli': patch
+'@ifc-lite/mcp': minor
+'@ifc-lite/viewer': patch
+---
+
+`byType()`, shared by `ifc-lite query --type`, MCP's `query_entities`/`count_entities` and the viewer SDK, expanded a caller's type through a fixed nine-entry table that only aliased `*StandardCase`/`*ElementedCase` pairs. An abstract EXPRESS supertype (`IfcBuildingElement`, `IfcElement`, `IfcBuiltElement`) is never a literal STEP entity type, so that table had no row for it and the query silently answered zero on a model full of walls, slabs and columns.
+
+`@ifc-lite/data` gains `expandTypeNamesToDescendants`, a descendant-closure resolver over the bundled `ENTITIES_IFC2X3`/`ENTITIES_IFC4`/`ENTITIES_IFC4X3` tables, and `@ifc-lite/parser`'s `expandTypes` delegates to it. Both take the queried model's `schemaVersion`, and `validate`'s scanned type lists are computed per store for the same reason.
+
+Three things about the resolution are deliberate:
+
+- **It reads the file's own schema first, and the other tables only for spellings that schema does not have.** Three parts: (a) the descendants the file's own schema table declares; (b) plus names that table does not declare *at all* and that are descendants of the requested type in the table that does declare them, which is how an IFC4X3-headered file still carrying `IFCSLABSTANDARDCASE` is found (`entityIndex.byType` is keyed by the names a file contains, not by what its `FILE_SCHEMA` header claims, and re-headered files are common); (c) plus the two alias relations below. A name the file's own schema declares under a different parent is never added: buildingSMART re-parented entities between versions, so a plain union would answer `byType('IfcBuildingElement')` on an IFC4 file with reinforcing bars, `byType('IfcObject')` with the `IfcProject`, and `byType('IfcSystem')` on IFC2X3 with an `IfcZone`.
+- **Cross-schema renames and the aliased leaves resolve too.** `IfcBuildingElement` and `IfcBuiltElement` reach each other's subtypes, and `byType('IfcGeotechnicalStratum')` now finds `IfcSolidStratum`/`IfcVoidStratum`/`IfcWaterStratum`, which no bundled table declares.
+- **The expansion does not cross an `IfcRoot` branch.** Descending the whole hierarchy from `IfcRoot` or `IfcObjectDefinition` would answer with every rooted record in the file (property sets, relationships, type objects), which contradicts what the same backends answer for an unfiltered query and breaks `group_by: storey`. A type named explicitly is never gated, so `byType('IfcPropertySet')` still works.
+
+The expansion order is now the requested type followed by its descendants sorted, rather than depth-first traversal order: callers page these results with `offset`/`limit`, and traversal order would shift a caller's page whenever the generated schema tables were regenerated.
+
+`expandTypes` is a published export of `@ifc-lite/parser` and of `@ifc-lite/mcp/browser`, so its `schemaVersion` parameter is optional and `expandTypes(['IfcWall'])` still compiles. Omitted, it falls back to the union across the three bundled schemas, which finds every leaf spelling but cannot tell a re-parented entity from a real subtype. Passing the queried model's `store.schemaVersion` is what makes the answer exact, and every caller in this repository passes it.
+
+Those two packages are minor rather than patch. The signature is compatible, but the array a surviving export returns is not: `expandTypes(['IfcWall'])` answered `['IFCWALL', 'IFCWALLSTANDARDCASE', 'IFCWALLELEMENTEDCASE']` and now answers `['IFCWALL', 'IFCWALLELEMENTEDCASE', 'IFCWALLSTANDARDCASE']`, and for an abstract supertype the set itself grows from empty to the whole closure. A consumer indexing into that array reads a different name at the same position. The old order cannot be kept — it was the nine-entry table's insertion order, and there is no table any more — so the release is labelled for what it does instead.
+
+IDS entity-facet matching is unchanged, per the buildingSMART IDS spec's no-automatic-inheritance rule (now cited in a code comment on `checkEntityFacet`).
@@ -0,0 +1,126 @@
+/* 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/. */
+
+/**
+ * `queryEntities()`'s `descriptor.types` expansion used to walk a fixed
+ * nine-entry `IFC_SUBTYPES` table (only `*StandardCase`/`*ElementedCase`
+ * aliases), imported from `@ifc-lite/parser`. Asking for an abstract EXPRESS
+ * supertype (`IfcBuildingElement`, `IfcElement`) is never a literal STEP
+ * entity type, so that table had no row for it and querying by it silently
+ * answered zero entities on a model full of matching elements. `expandTypes`
+ * now delegates to `@ifc-lite/data`'s schema-driven descendant resolver,
+ * which reads the model's own `schemaVersion` first and the other bundled
+ * tables only for leaf spellings that schema does not declare at all.
+ *
+ * The last case is the one that pins this adapter rather than the resolver.
+ * `schemaVersion` is an OPTIONAL parameter of `expandTypes` (it has to be: the
+ * function is published, and requiring it would be a major), and omitting it
+ * unions the three bundled schemas rather than failing. So a caller that stops
+ * passing it does not break the build and does not break the other cases here
+ * either, since a union is a superset and they all assert presence. This one
+ * asserts an ABSENCE that only the per-schema answer has, which is what makes
+ * it red when the argument goes away.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { IfcParser, type IfcDataStore } from '@ifc-lite/parser';
+import { createQueryAdapter } from './query-adapter.js';
+import type { StoreApi } from './types.js';
+
+function guid(mnemonic: string): string {
+  return (mnemonic + '0'.repeat(22)).slice(0, 22);
+}
+
+function ifcFile(dataSection: string, schema: string): string {
+  return `ISO-10303-21;
+HEADER;
+FILE_DESCRIPTION((''),'2;1');
+FILE_NAME('m','2026',(''),(''),'','','');
+FILE_SCHEMA(('${schema}'));
+ENDSEC;
+DATA;
+#1= IFCPROJECT('${guid('PROJ')}',$,'Proj',$,$,$,$,(#20),#30);
+#20= IFCGEOMETRICREPRESENTATIONCONTEXT($,'Model',3,1.E-5,#21,$);
+#21= IFCAXIS2PLACEMENT3D(#22,$,$);
+#22= IFCCARTESIANPOINT((0.,0.,0.));
+#30= IFCUNITASSIGNMENT((#31));
+#31= IFCSIUNIT(*,.LENGTHUNIT.,$,.METRE.);
+${dataSection}
+ENDSEC;
+END-ISO-10303-21;
+`;
+}
+
+const IFC4_MODEL = ifcFile(`#70= IFCWALL('${guid('WAL1')}',$,'Wall 1',$,$,$,$,'tag',$);
+#71= IFCWALLSTANDARDCASE('${guid('WAL2')}',$,'Wall 2',$,$,$,$,'tag',$);
+#72= IFCSLAB('${guid('SLAB')}',$,'Slab',$,$,$,$,'tag',$);
+#73= IFCCOLUMN('${guid('COLM')}',$,'Column',$,$,$,$,'tag',$);`, 'IFC4');
+
+const IFC4X3_MODEL = ifcFile(`#70= IFCWALL('${guid('WAL1')}',$,'Wall',$,$,$,$,'tag',$);
+#71= IFCCOURSE('${guid('CRSE')}',$,'Course',$,$,$,$,'tag',$);`, 'IFC4X3');
+
+// IFC2X3 puts IfcProject under IfcObject; IFC4 moved it to IfcContext. The
+// fixture's IFCPROJECT therefore answers `byType('IfcObject')` on this model
+// and not on the IFC4 one, which is what makes the last case discriminate.
+const IFC2X3_MODEL = ifcFile(`#70= IFCWALL('${guid('WAL1')}',$,'Wall',$,$,$,$,'tag');`, 'IFC2X3');
+
+function makeStore(dataStore: IfcDataStore): StoreApi {
+  return {
+    getState: () => ({ ifcDataStore: dataStore, models: new Map() }),
+    subscribe: () => () => {},
+  } as unknown as StoreApi;
+}
+
+async function parse(source: string): Promise<IfcDataStore> {
+  const parser = new IfcParser();
+  const buffer = new TextEncoder().encode(source).buffer as ArrayBuffer;
+  return parser.parseColumnar(buffer);
+}
+
+test('queryEntities("IfcBuildingElement") finds all 4 concrete building elements, not 0 (IFC4)', async () => {
+  const dataStore = await parse(IFC4_MODEL);
+  const adapter = createQueryAdapter(makeStore(dataStore));
+  const results = adapter.entities({ modelId: 'default', types: ['IfcBuildingElement'] });
+  assert.equal(results.length, 4);
+});
+
+test('queryEntities("IfcWall") still returns 2 — no regression on the StandardCase alias', async () => {
+  const dataStore = await parse(IFC4_MODEL);
+  const adapter = createQueryAdapter(makeStore(dataStore));
+  const results = adapter.entities({ modelId: 'default', types: ['IfcWall'] });
+  assert.equal(results.length, 2);
+});
+
+test('queryEntities("IfcFooting") — a real IFC type with no instances in this fixture — returns 0', async () => {
+  const dataStore = await parse(IFC4_MODEL);
+  const adapter = createQueryAdapter(makeStore(dataStore));
+  const results = adapter.entities({ modelId: 'default', types: ['IfcFooting'] });
+  assert.equal(results.length, 0);
+});
+
+test('queryEntities("IfcBuiltElement") resolves the IFC4X3 rename of IfcBuildingElement', async () => {
+  const dataStore = await parse(IFC4X3_MODEL);
+  const adapter = createQueryAdapter(makeStore(dataStore));
+  const results = adapter.entities({ modelId: 'default', types: ['IfcBuiltElement'] });
+  assert.equal(results.length, 2);
+});
+
+test('queryEntities("IfcObject") follows the model\'s own schema, not a default (IFC2X3)', async () => {
+  // IfcProject is an IfcObject in IFC2X3 and an IfcContext from IFC4 on. Both
+  // halves matter: the first says the IFC2X3 model finds its project, and the
+  // second says the IFC4 model does NOT. Drop the `store.schemaVersion`
+  // argument and the expansion unions the schemas, IFCPROJECT comes back on
+  // IFC4 too, and the second half fails.
+  const dataStore = await parse(IFC2X3_MODEL);
+  assert.equal(dataStore.schemaVersion, 'IFC2X3');
+  const adapter = createQueryAdapter(makeStore(dataStore));
+  const results = adapter.entities({ modelId: 'default', types: ['IfcObject'] });
+  assert.equal(results.length, 2);
+
+  const ifc4 = await parse(IFC4_MODEL);
+  const ifc4Adapter = createQueryAdapter(makeStore(ifc4));
+  const ifc4Results = ifc4Adapter.entities({ modelId: 'default', types: ['IfcObject'] });
+  assert.ok(!ifc4Results.some((e) => e.type.toUpperCase() === 'IFCPROJECT'));
+});
@@ -195,9 +195,15 @@ export function createQueryAdapter(store: StoreApi): QueryBackendMethods {
 
       let entityIds: number[];
       if (descriptor.types && descriptor.types.length > 0) {
-        // Expand types to include IFC4 subtypes (e.g., IfcWall → IfcWallStandardCase)
+        // Expand types to every schema-declared descendant (IfcWall →
+        // IfcWallStandardCase, IfcBuildingElement → its concrete leaves).
+        // Resolved against this model's own schema, plus the leaf spellings
+        // that schema does not declare at all, so neither the FILE_SCHEMA
+        // header alone nor a plain union across the bundled tables decides
+        // what its records answer. The version argument is load-bearing:
+        // buildingSMART re-parented entities between versions.
         entityIds = [];
-        for (const type of expandTypes(descriptor.types)) {
+        for (const type of expandTypes(descriptor.types, model.ifcDataStore.schemaVersion)) {
           const typeIds = model.ifcDataStore.entityIndex.byType.get(type) ?? [];
           for (const id of typeIds) entityIds.push(id);
         }
 
@@ -19,12 +19,13 @@
 
 import { describe, it, expect } from 'vitest';
 import { IfcParser, IFC_SUBTYPES, expandTypes, type IfcDataStore } from '@ifc-lite/parser';
+import { loadInlineModel } from '../headless-test-helpers.js';
 import {
   computeValidationIssues,
   NAMED_ELEMENT_BASE_TYPES,
   QUANTIFIABLE_BASE_TYPES,
-  NAMED_ELEMENT_TYPES,
-  QUANTIFIABLE_TYPES,
+  namedElementTypes,
+  quantifiableTypes,
 } from './validate.js';
 
 function buildIfc(dataLines: string[]): string {
@@ -95,12 +96,17 @@ describe('validate covers the concrete subtypes of the types it lists', () => {
 
 describe('the scanned type lists stay derived, not hand-copied', () => {
   it.each([
-    ['named-elements', NAMED_ELEMENT_BASE_TYPES, NAMED_ELEMENT_TYPES],
-    ['quantity-completeness', QUANTIFIABLE_BASE_TYPES, QUANTIFIABLE_TYPES],
+    ['named-elements', NAMED_ELEMENT_BASE_TYPES, namedElementTypes],
+    ['quantity-completeness', QUANTIFIABLE_BASE_TYPES, quantifiableTypes],
   ])('%s expands exactly the subtypes the schema declares', (_rule, bases, scanned) => {
     // Both directions: every declared subtype of a listed base is scanned, and
     // nothing is scanned that the base list plus the schema does not imply.
-    expect([...scanned].sort()).toEqual([...new Set(expandTypes([...bases]))].sort());
+    // Per schema version, because the answer is not the same on each.
+    for (const version of ['IFC2X3', 'IFC4', 'IFC4X3']) {
+      expect([...scanned(version)].sort(), version).toEqual(
+        [...new Set(expandTypes([...bases], version))].sort(),
+      );
+    }
   });
 
   it.each([
@@ -113,3 +119,73 @@ describe('the scanned type lists stay derived, not hand-copied', () => {
     expect([...bases].filter((t) => subtypes.has(t))).toEqual([]);
   });
 });
+
+/**
+ * The scanned lists are computed PER STORE, from the model's own
+ * `schemaVersion`.
+ *
+ * They were computed once at module load, with no model in hand, which is only
+ * sound while the expansion is a property of the schema tables alone. It is
+ * not: a descendant set differs by version, so a list frozen at the IFC4
+ * answer counted records on an IFC4X3 file that `byType` did not — the exact
+ * disagreement the doc at the top of `validate.ts` says cannot happen.
+ *
+ * `validate-subtypes`'s other cases all parse IFC4 fixtures, so they compare
+ * two IFC4 answers and cannot see it. These are IFC4X3 and IFC2X3 on purpose,
+ * and they compare the validator against a real `byType` over the SAME store
+ * rather than pinning the shape of the function that feeds both.
+ */
+describe('the scanned lists and byType agree on a file that is not IFC4', () => {
+  const SLABS = [
+    "#10=IFCSLAB('0Slab_GUID_00000001',$,$,$,$,$,$,$,$);",
+    "#11=IFCSLABSTANDARDCASE('0SlabSC_GUID_000001',$,$,$,$,$,$,$,$);",
+  ];
+
+  function buildIfcWithSchema(schema: string, dataLines: string[]): string {
+    return [
+      'ISO-10303-21;',
+      'HEADER;',
+      "FILE_DESCRIPTION((''),'2;1');",
+      "FILE_NAME('t.ifc','2026-01-01T00:00:00',(''),(''),'','','');",
+      `FILE_SCHEMA(('${schema}'));`,
+      'ENDSEC;',
+      'DATA;',
+      ...dataLines,
+      'ENDSEC;',
+      'END-ISO-10303-21;',
+      '',
+    ].join('\n');
+  }
+
+  it.each(['IFC2X3', 'IFC4', 'IFC4X3'])(
+    'named-elements counts both slabs on a %s file, and byType finds both',
+    async (schema) => {
+      const source = buildIfcWithSchema(schema, [...SPATIAL, ...SLABS]);
+      const store = await parse(source);
+      expect(store.schemaVersion).toBe(schema);
+
+      const counted = issueFor(store, 'named-elements');
+      expect(counted?.message).toBe('2 building elements have no Name');
+
+      const bim = await loadInlineModel(source, `validate-${schema}`);
+      expect(bim.query().byType('IfcSlab').toArray()).toHaveLength(2);
+    },
+  );
+
+  it.each(['IFC2X3', 'IFC4', 'IFC4X3'])(
+    'the validator scans exactly the buckets byType reads, on the same %s store',
+    async (schema) => {
+      // The behavioural form of the invariant: same store, same question. A
+      // list computed against a different schema than the store's would show
+      // up here as a bucket one side reads and the other does not.
+      const source = buildIfcWithSchema(schema, [...SPATIAL, ...SLABS]);
+      const store = await parse(source);
+      const scanned = new Set(namedElementTypes(store.schemaVersion));
+
+      const bim = await loadInlineModel(source, `validate-buckets-${schema}`);
+      const queried = bim.query().byType('IfcSlab').toArray().map((e) => e.type.toUpperCase());
+      expect(queried.length).toBeGreaterThan(0);
+      for (const type of queried) expect(scanned, `${schema}: ${type}`).toContain(type);
+    },
+  );
+});
@@ -64,6 +64,9 @@ interface DanglingReference {
  * out none of the ten at all. `expandTypes` is the same expansion every
  * `byType()` backend uses, so these rules and a `byType('IfcWall')` query
  * cannot disagree about what counts as a wall.
+ * Which is why they are computed PER STORE, not once at module load:
+ * `expandTypes` reads the model's own `schemaVersion`, and a list frozen at the
+ * IFC4 answer counts records on an IFC2X3 or IFC4X3 file that `byType` does not.
  */
 export const NAMED_ELEMENT_BASE_TYPES: readonly string[] = ['IFCWALL', 'IFCSLAB', 'IFCCOLUMN', 'IFCBEAM',
   'IFCDOOR', 'IFCWINDOW', 'IFCSTAIR', 'IFCROOF', 'IFCSPACE', 'IFCRAILING', 'IFCMEMBER', 'IFCPLATE', 'IFCFOOTING'];
@@ -72,11 +75,13 @@ export const NAMED_ELEMENT_BASE_TYPES: readonly string[] = ['IFCWALL', 'IFCSLAB'
 export const QUANTIFIABLE_BASE_TYPES: readonly string[] = ['IFCWALL', 'IFCSLAB', 'IFCCOLUMN', 'IFCBEAM',
   'IFCDOOR', 'IFCWINDOW', 'IFCSTAIR', 'IFCROOF', 'IFCSPACE', 'IFCMEMBER', 'IFCPLATE', 'IFCFOOTING'];
 
-/** `NAMED_ELEMENT_BASE_TYPES` plus every subtype the schema declares under one. */
-export const NAMED_ELEMENT_TYPES: readonly string[] = expandTypes([...NAMED_ELEMENT_BASE_TYPES]);
+/** `NAMED_ELEMENT_BASE_TYPES` plus every subtype this store's schema declares under one. */
+export const namedElementTypes = (schemaVersion: string | undefined): readonly string[] =>
+  expandTypes([...NAMED_ELEMENT_BASE_TYPES], schemaVersion);
 
-/** `QUANTIFIABLE_BASE_TYPES` plus every subtype the schema declares under one. */
-export const QUANTIFIABLE_TYPES: readonly string[] = expandTypes([...QUANTIFIABLE_BASE_TYPES]);
+/** `QUANTIFIABLE_BASE_TYPES` plus every subtype this store's schema declares under one. */
+export const quantifiableTypes = (schemaVersion: string | undefined): readonly string[] =>
+  expandTypes([...QUANTIFIABLE_BASE_TYPES], schemaVersion);
 
 /** Cap on individually-reported dangling references; the remainder is rolled into one summary issue. */
 const DANGLING_REF_ISSUE_CAP = 50;
@@ -284,7 +289,7 @@ export function computeValidationIssues(store: IfcDataStore): ValidationIssue[]
 
   // 4. Check for unnamed elements
   let unnamedCount = 0;
-  for (const pt of NAMED_ELEMENT_TYPES) {
+  for (const pt of namedElementTypes(store.schemaVersion)) {
     const ids = store.entityIndex.byType.get(pt) ?? [];
     for (const id of ids) {
       const node = new EntityNode(store, id);
@@ -303,7 +308,7 @@ export function computeValidationIssues(store: IfcDataStore): ValidationIssue[]
   // 6. Quantity completeness — check if product entities have quantity sets
   let withQuantities = 0;
   let withoutQuantities = 0;
-  for (const qt of QUANTIFIABLE_TYPES) {
+  for (const qt of quantifiableTypes(store.schemaVersion)) {
     const ids = store.entityIndex.byType.get(qt) ?? [];
     for (const id of ids) {
       const node = new EntityNode(store, id);