@ifc-lite/rules 0.2.0

package/dist/filter/filter-groups.js

@@ -0,0 +1,136 @@
+/* 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/. */
+/**
+ * `FilterGroup` — one AND-combined (or OR-combined, per its own
+ * `combinator`) list of `FilterRule`s. A `SearchFilterStateValue` (and a
+ * saved filter, #4904) carries an ARRAY of these; groups themselves are
+ * always OR'd together, mirroring the selector grammar's `+` union
+ * (`IfcSlab, material=concrete + IfcDoor` → two groups).
+ *
+ * Kept in its own file (not folded into `filter-rules.ts`, already near the
+ * module-size cap) so both the evaluator and the serialization layer can
+ * import it without pulling in the whole rule taxonomy's JSON guards.
+ */
+import { isFilterRule } from './filter-rules.js';
+/** A fresh, empty AND group — what a brand-new filter (or a brand-new
+ *  group added in the builder) starts from. */
+export function emptyFilterGroup() {
+    return { rules: [], combinator: 'AND' };
+}
+export function isFilterGroup(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const g = value;
+    return (Array.isArray(g.rules) &&
+        g.rules.every(isFilterRule) &&
+        (g.combinator === 'AND' || g.combinator === 'OR'));
+}
+/**
+ * Render `groups` back as selector-ish text — NOT a full inverse of
+ * `parseSelector`/`selectorToFilterRules` (most rule kinds have no single
+ * canonical spelling; a regex `Name` rule and a typed-in `contains` rule
+ * both become `Rule.name`, and only one of those round-trips through text).
+ * What this DOES round-trip exactly is the shape the selector's own union
+ * syntax cares about: class names (`IfcWall`, `IfcDoor`, …) and GlobalIds,
+ * `+`-joined across groups. Used by the Selector field to echo back what
+ * the CURRENT filter state reads as, so adding a second group in the
+ * builder is visible as a second `+`-joined clause without leaving the
+ * builder (#4904).
+ *
+ * All-or-nothing: an empty group, or a group whose rules do not reduce to
+ * exactly ONE renderable clause, makes the WHOLE echo `''` rather than a
+ * partial rendering — review (PR #4987) caught that joining per-group
+ * fragments with `+` regardless produced text that read as a DIFFERENT
+ * query than what evaluation actually runs: an empty group left a
+ * dangling ` + `, and several `ifcType`/`globalId` rules AND'd within one
+ * group rendered as comma-separated union terms (selector-text unions use
+ * `,` to ADD classes, not narrow them), so a two-rule AND group echoed as
+ * something the evaluator would read as broader than what it actually
+ * matches. Silently showing a narrower or broader query back to the user
+ * is the same "matched nothing, said nothing" defect class #4091 exists to
+ * avoid, so this omits the echo entirely rather than guess.
+ */
+export function groupsToSelectorText(groups) {
+    const clauses = [];
+    for (const group of groups) {
+        if (group.rules.length === 0)
+            continue;
+        if (group.rules.length !== 1)
+            return '';
+        const clause = ruleToSelectorClause(group.rules[0]);
+        if (clause === null)
+            return '';
+        clauses.push(clause);
+    }
+    return clauses.join(' + ');
+}
+function ruleToSelectorClause(rule) {
+    switch (rule.kind) {
+        case 'ifcType':
+            if (!Array.isArray(rule.values) || rule.values.length === 0)
+                return null;
+            return rule.values.map((v) => (rule.op === 'notIn' ? `! ${v}` : v)).join(', ');
+        case 'globalId':
+            if (!Array.isArray(rule.values) || rule.values.length === 0)
+                return null;
+            return rule.values.map((v) => (rule.op === 'notIn' ? `! ${v}` : v)).join(', ');
+        default:
+            // Every other rule kind has no single canonical selector spelling —
+            // omitted rather than guessed. See the module doc above.
+            return null;
+    }
+}
+/** The rules of `groups[activeIndex]`, clamped into range — what the
+ *  builder's active-group actions (`addFilterRule` etc., `searchSlice.
+ *  filterGroups.ts`) operate on. Callers outside the store (HierarchyPanel's
+ *  upsert-by-kind) read this instead of reimplementing the clamp. */
+export function activeGroupRules(groups, activeIndex) {
+    if (groups.length === 0)
+        return [];
+    const i = Math.max(0, Math.min(activeIndex, groups.length - 1));
+    return groups[i]?.rules ?? [];
+}
+/** Total rule count across every group — what "empty filter" checks and rule
+ *  count badges read, since a `groups.length === 1` filter with zero rules
+ *  in that one group must still read as empty. */
+export function totalRuleCount(groups) {
+    let n = 0;
+    for (const g of groups)
+        n += g.rules.length;
+    return n;
+}
+/**
+ * Parse a persisted `groups` array, refusing (returning `null`) the WHOLE
+ * query rather than silently dropping a group this build cannot read. A
+ * saved filter with an unreadable group is exactly the "matched nothing,
+ * said nothing" defect class #4091 exists to avoid — narrowing it to the
+ * readable groups would change which elements a `+` union matches without
+ * telling anyone.
+ */
+export function parseFilterGroups(raw) {
+    if (!Array.isArray(raw) || raw.length === 0)
+        return null;
+    const groups = [];
+    for (const entry of raw) {
+        if (typeof entry !== 'object' || entry === null)
+            return null;
+        const g = entry;
+        if (!Array.isArray(g.rules))
+            return null;
+        // Every rule in a persisted group must parse — a group carrying even
+        // one rule this build cannot read is not "mostly readable", it is a
+        // different query, so the whole thing is refused (see module doc).
+        if (!g.rules.every(isFilterRule))
+            return null;
+        // A missing/corrupted combinator must refuse too, not default to AND —
+        // review (PR #4987): silently coercing a dropped/garbled `OR` into
+        // `AND` changes which elements the group matches without telling
+        // anyone, the exact defect class this whole function exists to avoid.
+        if (g.combinator !== 'AND' && g.combinator !== 'OR')
+            return null;
+        groups.push({ rules: g.rules, combinator: g.combinator });
+    }
+    return groups;
+}
+//# sourceMappingURL=filter-groups.js.map

package/dist/filter/filter-groups.js.map

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

package/dist/filter/filter-iteration-source.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Iteration-source selection (index prefilter) and cheap-first rule
+ * ordering for the path-B evaluator.
+ *
+ * Split out of `filter-evaluate.ts` (which keeps the orchestration /
+ * per-entity loop) to stay under the module size cap — both pieces here are
+ * pure given `store`/`rules`, which is what makes them unit-testable without
+ * an `EvalContext`.
+ */
+import { type IfcDataStore } from '@ifc-lite/parser';
+import { type MutablePropertyView } from '@ifc-lite/mutations';
+import type { Combinator, FilterRule } from './filter-rules.js';
+/** Return the raw expressId column as the iteration source. The per-entity
+ *  loops already skip empty rows (`if (!expressId) continue`) so the
+ *  typed-array shape is correctness-safe AND lets the federated entry report
+ *  a `total` rather than streaming with `total = -1`. */
+export declare function iterateAllExpressIds(store: IfcDataStore): ArrayLike<number>;
+/**
+ * Decide which expressIds the evaluator walks. Public for testability —
+ * consumers should only depend on the results returned, not on the
+ * iteration count, but a benchmark / regression test may want to assert
+ * the prefilter actually narrows.
+ */
+export declare function selectIterationSource(store: IfcDataStore, rules: readonly FilterRule[], combinator: Combinator, candidateExpressIds: Iterable<number> | undefined, modelId?: string, mutationView?: MutablePropertyView): ArrayLike<number> | Iterable<number>;
+export declare function orderRulesByCost(rules: readonly FilterRule[]): FilterRule[];
+//# sourceMappingURL=filter-iteration-source.d.ts.map

package/dist/filter/filter-iteration-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-iteration-source.d.ts","sourceRoot":"","sources":["../../src/filter/filter-iteration-source.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AAEH,OAAO,EAAyB,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC5E,OAAO,EAA6B,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1F,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAKhE;;;yDAGyD;AACzD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,CAAC,MAAM,CAAC,CAE3E;AAgBD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,UAAU,EAAE,UAAU,EACtB,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,SAAS,EACjD,OAAO,CAAC,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,mBAAmB,GACjC,SAAS,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,CAuCtC;AAoED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE,CAO3E"}

package/dist/filter/filter-iteration-source.js

@@ -0,0 +1,154 @@
+/* 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/. */
+/**
+ * Iteration-source selection (index prefilter) and cheap-first rule
+ * ordering for the path-B evaluator.
+ *
+ * Split out of `filter-evaluate.ts` (which keeps the orchestration /
+ * per-entity loop) to stay under the module size cap — both pieces here are
+ * pure given `store`/`rules`, which is what makes them unit-testable without
+ * an `EvalContext`.
+ */
+import { isQueryableObjectType } from '@ifc-lite/parser';
+import { iterateEffectiveEntityIds } from '@ifc-lite/mutations';
+import { unionByStorey } from './filter-match.js';
+// ── Iteration source: index prefilter (AND + op:in) ──────────────────────────
+/** Return the raw expressId column as the iteration source. The per-entity
+ *  loops already skip empty rows (`if (!expressId) continue`) so the
+ *  typed-array shape is correctness-safe AND lets the federated entry report
+ *  a `total` rather than streaming with `total = -1`. */
+export function iterateAllExpressIds(store) {
+    return store.entities.expressId;
+}
+function* effectiveFilterIds(store, view, types) {
+    const sourceIds = types ? undefined : store.entities.expressId;
+    for (const { expressId, type, overlayCreated } of iterateEffectiveEntityIds(store, view, types, sourceIds)) {
+        // An untyped search historically scanned EntityTable rows, not every STEP
+        // geometry primitive. A typed search already used the source type bucket.
+        if (!types && overlayCreated && !isQueryableObjectType(type))
+            continue;
+        yield expressId;
+    }
+}
+/**
+ * Decide which expressIds the evaluator walks. Public for testability —
+ * consumers should only depend on the results returned, not on the
+ * iteration count, but a benchmark / regression test may want to assert
+ * the prefilter actually narrows.
+ */
+export function selectIterationSource(store, rules, combinator, candidateExpressIds, modelId, mutationView) {
+    // Caller-supplied narrowing wins (Tier-1 candidates).
+    if (candidateExpressIds !== undefined)
+        return candidateExpressIds;
+    if (mutationView?.hasPendingChanges()) {
+        // A source type bucket omits entities retyped into it and newly created
+        // entities. Keep the same AND narrowing when it is safe, but apply it to
+        // the effective ID set rather than the parser's immutable index.
+        if (combinator === 'AND') {
+            const typeRule = rules.find((rule) => rule.kind === 'ifcType' && rule.op === 'in' && rule.values.length > 0);
+            if (typeRule?.kind === 'ifcType') {
+                return effectiveFilterIds(store, mutationView, typeRule.values);
+            }
+        }
+        return effectiveFilterIds(store, mutationView);
+    }
+    // Prefilter only applies under AND. OR rules are unioned; you can't
+    // shrink the candidate set from a single OR clause without losing
+    // results from the other clauses.
+    if (combinator !== 'AND')
+        return iterateAllExpressIds(store);
+    // Try to find the smallest narrowing source. Multiple op:in rules in
+    // the same query can each suggest a candidate bucket; we pick the
+    // smallest one (the per-entity loop re-checks every rule, so any one
+    // valid bucket is correctness-safe — fewer rows = less work).
+    let best = null;
+    for (const rule of rules) {
+        if (rule.kind === 'ifcType' && rule.op === 'in' && rule.values.length > 0) {
+            const bucket = unionByType(store, rule.values);
+            if (bucket && (best === null || bucket.length < best.length))
+                best = bucket;
+        }
+        else if (rule.kind === 'storey' && rule.op === 'in' && rule.values.length > 0) {
+            const bucket = unionByStorey(store, rule, modelId);
+            if (bucket && (best === null || bucket.length < best.length))
+                best = bucket;
+        }
+    }
+    return best ?? iterateAllExpressIds(store);
+}
+function unionByType(store, names) {
+    // @raw-entity-enumeration-ok selectIterationSource reaches this source-bucket fast path only when no mutation view has pending changes
+    const byType = store.entityIndex.byType;
+    if (!byType || byType.size === 0)
+        return null;
+    // STEP type names are stored UPPERCASE; rule values arrive in canonical
+    // PascalCase ("IfcWall") so we uppercase here at the boundary.
+    const out = [];
+    for (const name of names) {
+        const bucket = byType.get(name.toUpperCase());
+        if (bucket)
+            for (const id of bucket)
+                out.push(id);
+    }
+    return out.length > 0 ? out : null;
+}
+// ── Cheap-first rule ordering ────────────────────────────────────────────────
+/**
+ * AGENTS.md §2: never call `extractPropertiesOnDemand` in a large loop.
+ * We can't avoid it entirely for `property`/`quantity` rules, but we can
+ * make sure cheap rules check first so AND/OR short-circuit skips the
+ * expensive parse for entities that already fail/pass.
+ */
+const RULE_COST = {
+    // Constant-time comparison against the entity's owning model.
+    model: 0,
+    // Constant-time set lookups against the owning model's tag set (#4215).
+    modelTag: 0,
+    // Column-only — single TypedArray read.
+    ifcType: 0,
+    // Pre-built reverse-map lookup.
+    storey: 1,
+    // Pre-built reverse-map lookup (elementToStorey → storeyElevations).
+    elevation: 1,
+    // String-table indirection.
+    name: 2,
+    // Column-only — same TypedArray read as ifcType, just a different column.
+    globalId: 0,
+    // Source-buffer parse (resolveEntityPredefinedType re-reads the entity's
+    // attributes) - same cost class as a pset parse, so order it after the
+    // cheap column checks that can short-circuit it. (#1462)
+    predefinedType: 10,
+    // Source-buffer parse (the AGENTS.md §2 hot path).
+    property: 10,
+    quantity: 10,
+    // Source-buffer parse (extractAllEntityAttributes) — same cost class.
+    attribute: 10,
+    // Relationship-graph walk + on-demand resolve — as costly as a pset parse.
+    material: 10,
+    classification: 10,
+    // One reverse-relationship lookup (IfcRelDefinesByType) + a columnar
+    // Name read on the resolved type id — no source-buffer parse, so it's
+    // cheap like `storey`/`elevation`, not `material`/`classification`.
+    type: 1,
+    // Relationship-graph walk (potentially multi-hop, containment +
+    // aggregation) plus a columnar Name read on each ancestor — no
+    // source-buffer parse, but costlier than the single-hop `type` lookup, so
+    // it sits with `material`/`classification`. No `op:'in'` prefilter bucket
+    // exists for it either (#4903's maintainer ruling: fall back to a full
+    // scan for `parent=`, the same trade-off `location=` already accepted,
+    // and narrow only if a real perf number asks for it).
+    parent: 10,
+    // One reverse-relationship lookup (IfcRelAssignsToGroup) + a columnar
+    // Name/class read per group, like `type`; no source-buffer parse.
+    group: 1,
+};
+export function orderRulesByCost(rules) {
+    // Stable sort — equal-cost rules retain their authored order so the
+    // user's intent is visible in debug logs / SQL preview.
+    return rules
+        .map((r, i) => ({ r, i, cost: RULE_COST[r.kind] }))
+        .sort((a, b) => a.cost - b.cost || a.i - b.i)
+        .map((x) => x.r);
+}
+//# sourceMappingURL=filter-iteration-source.js.map

package/dist/filter/filter-iteration-source.js.map

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

package/dist/filter/filter-iteration.d.ts

@@ -0,0 +1,5 @@
+export declare function isNumericArrayLike(value: unknown): value is ArrayLike<number>;
+export declare function toNumericIterable(source: ArrayLike<number> | Iterable<number>): Iterable<number>;
+/** Materialise known-size collections for indexed chunking and progress. */
+export declare function materialiseNumericIterable(source: ArrayLike<number> | Iterable<number>): ArrayLike<number> | null;
+//# sourceMappingURL=filter-iteration.d.ts.map

package/dist/filter/filter-iteration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-iteration.d.ts","sourceRoot":"","sources":["../../src/filter/filter-iteration.ts"],"names":[],"mappings":"AAIA,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAAC,MAAM,CAAC,CAG7E;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,GAC3C,QAAQ,CAAC,MAAM,CAAC,CAMlB;AAED,4EAA4E;AAC5E,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,GAC3C,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,CAI1B"}

package/dist/filter/filter-iteration.js

@@ -0,0 +1,25 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+export function isNumericArrayLike(value) {
+    return typeof value === 'object' && value !== null
+        && typeof value.length === 'number';
+}
+export function toNumericIterable(source) {
+    if (Symbol.iterator in Object(source))
+        return source;
+    return (function* () {
+        const arr = source;
+        for (let i = 0; i < arr.length; i++)
+            yield arr[i];
+    })();
+}
+/** Materialise known-size collections for indexed chunking and progress. */
+export function materialiseNumericIterable(source) {
+    if (Array.isArray(source) || isNumericArrayLike(source))
+        return source;
+    if (source instanceof Set)
+        return Array.from(source);
+    return null;
+}
+//# sourceMappingURL=filter-iteration.js.map

package/dist/filter/filter-iteration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-iteration.js","sourceRoot":"","sources":["../../src/filter/filter-iteration.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;WAC7C,OAAQ,KAA8B,CAAC,MAAM,KAAK,QAAQ,CAAC;AAClE,CAAC;AAED,MAAM,UAAU,iBAAiB,CAC/B,MAA4C;IAE5C,IAAI,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC;QAAE,OAAO,MAA0B,CAAC;IACzE,OAAO,CAAC,QAAQ,CAAC;QACf,MAAM,GAAG,GAAG,MAA2B,CAAC;QACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE;YAAE,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;IACpD,CAAC,CAAC,EAAE,CAAC;AACP,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,0BAA0B,CACxC,MAA4C;IAE5C,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,kBAAkB,CAAC,MAAM,CAAC;QAAE,OAAO,MAAM,CAAC;IACvE,IAAI,MAAM,YAAY,GAAG;QAAE,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACrD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/filter/filter-match.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Per-rule value resolution + matching for the path-B evaluator.
+ *
+ * Split out of `filter-evaluate.ts` (which keeps the iteration /
+ * orchestration logic) to stay under the module size cap. These helpers
+ * are pure given their inputs, which is what makes them unit-testable in
+ * `filter-evaluate.test.ts` via the evaluator's `__internal` re-export.
+ */
+import { extractPropertiesOnDemand, extractQuantitiesOnDemand, type IfcDataStore, type MaterialInfo, type ClassificationInfo } from '@ifc-lite/parser';
+import { type PropertyRule, type QuantityRule, type ClassificationRule, type AttributeRule, type StoreyRule, type ParentRule, type TextKind } from './filter-rules.js';
+/**
+ * Compare a rule's property-set / property name against a row's.
+ *
+ * `kind` is the rule saying what it holds (see {@link TextKind}). A `'regex'`
+ * name is a SOURCE and the whole string is the pattern, which is what makes
+ * the selector syntax's `/Pset_.*Common/.FireRating` reach `Pset_WallCommon`
+ * and `Pset_SlabCommon` in one rule; a `'literal'` name is compared as text
+ * even when it is spelled with slashes, which is what the grammar's quoting
+ * means and the only reason `"/Wall/".FireRating` can be asked for at all.
+ *
+ * A name with no declared kind was typed into a chip field, where the
+ * Lists-panel `/…/` convention (#1591) is the user's only way to say
+ * "pattern"; anything else there is the historical case-insensitive equality.
+ *
+ * `compileNameMatcher` throws when the regex body is syntactically valid but
+ * rejected by `@ifc-lite/regex-guard` as unsafe (catastrophic-backtracking
+ * shaped, or over the length cap) — see `filter-ops.ts`'s `regexOpMatches`
+ * docstring for the full contract. This function does not catch that; it
+ * propagates to `filter-evaluate.ts`'s caller, which must.
+ */
+export declare function nameMatches(rulePattern: string, rowName: string, kind?: TextKind): boolean;
+export interface PsetRow {
+    setName: string;
+    propertyName: string;
+    value: string;
+}
+export type PsetRows = ReadonlyArray<PsetRow>;
+export interface QtyRow {
+    setName: string;
+    quantityName: string;
+    value: number;
+}
+export type QtyRows = ReadonlyArray<QtyRow>;
+export declare function flattenPsets(psets: ReturnType<typeof extractPropertiesOnDemand>): PsetRows;
+export declare function flattenQtys(qtos: ReturnType<typeof extractQuantitiesOnDemand>): QtyRows;
+export declare function stringifyValue(value: unknown): string;
+export declare function matchPropertyRule(rule: PropertyRule, rows: PsetRows): boolean;
+/** One entity's generic named attributes, as `extractAllEntityAttributes`
+ *  returns them — schema-driven, string/number/boolean values only. */
+export type AttrRows = ReadonlyArray<{
+    name: string;
+    value: string | number | boolean;
+}>;
+/**
+ * Match an `attribute` rule (Description, ObjectType, Tag, LongName, any
+ * other schema-named attribute) against one entity's extracted attributes.
+ * Attribute NAME matching is case-insensitive, same as the IDS attribute
+ * facet this reuses the extraction from; the VALUE comparison reuses
+ * `valueOpMatches`, the same comparator `matchPropertyRule` uses, so a
+ * numeric attribute value compares the same way a numeric property does.
+ */
+export declare function matchAttributeRule(rule: AttributeRule, attrs: AttrRows): boolean;
+export declare function matchQuantityRule(rule: QuantityRule, rows: QtyRows): boolean;
+export declare function defaultStoreyName(store: IfcDataStore, expressId: number): string;
+/** Does `expressId` (in `modelId`) sit in a storey ref'd by `rule.refs`?
+ *  `IfcBuildingStorey.Name` isn't unique, so once a `StoreyRule` carries
+ *  an exact (modelId, expressId) ref (mirrored from a HierarchyPanel
+ *  click), matching bypasses Name entirely. Reaches through a containing
+ *  space via {@link storeyIdOf}, same as the Name-matched path. */
+export declare function storeyMatchesRefs(store: IfcDataStore, expressId: number, modelId: string, rule: StoreyRule): boolean;
+/** Index-prefilter twin of {@link storeyMatchesRefs}/Name matching: the
+ *  bucket of elements a `storey op:'in'` rule narrows to for `modelId`.
+ *  Includes each matched storey's directly-contained elements AND every
+ *  element `bySpace` lists for a space belonging to that storey, so this
+ *  prefilter can never exclude a candidate the (also widened) per-entity
+ *  check in `filter-evaluate.ts` would go on to match. */
+export declare function unionByStorey(store: IfcDataStore, rule: StoreyRule, modelId: string | undefined): number[] | null;
+/** Collect the *individual* material names an element exposes - each layer /
+ *  constituent / profile material, or the single plain material - for the
+ *  multi-valued `material` rule matcher and the material dropdown. Shares the
+ *  #1366 lens collector, so filtering by material groups by the real materials
+ *  rather than the layer-set / Revit family+type name that masked them. (#1462) */
+export declare function materialNamesOf(info: MaterialInfo | null): string[];
+/** `materialNamesOf` plus every material Category (`material=` matches
+ *  Name OR Category, #4094) — categories come from `flattenMaterials`
+ *  (`@ifc-lite/ids`'s material-facet flattener), reused rather than a
+ *  second layer/profile/constituent walk; only its `.category` field is
+ *  used, since its `.name` field also surfaces a layer's own label, which
+ *  `materialNamesOf` deliberately excludes (#1462). */
+export declare function materialMatchCandidates(info: MaterialInfo | null): string[];
+/**
+ * Match a classification rule against an element's classification refs.
+ * `system` (when set) scopes to one system; value ops match a ref's code
+ * (identification) OR name. Pushes both through even when `undefined`
+ * (absent) rather than filtering on truthy — `matchStringAnyNone` decides
+ * absent-vs-empty explicitly (#4930).
+ */
+export declare function matchClassificationRule(rule: ClassificationRule, refs: readonly ClassificationInfo[]): boolean;
+/** Element elevation in metres, derived from its building storey's
+ *  elevation. Returns null when the element isn't placed in the spatial
+ *  hierarchy (so an elevation rule simply doesn't match it). */
+export declare function elevationOf(store: IfcDataStore, expressId: number): number | null;
+/**
+ * `parent=Foo` (#4903) — does ANY ancestor of `expressId`, walking upward
+ * through spatial containment and aggregation to any depth via
+ * `collectSpatialAncestors` (`@ifc-lite/data`, the single shared resolver),
+ * have a Name the rule's op matches? Reuses `matchStringAnyNone`, the same
+ * multi-valued convention `material`/`classification` rules use: an element
+ * with NO ancestors — or none whose Name matches — satisfies neither a
+ * positive nor a negative op (#4659). `getNameOrUndefined`, not `getName`,
+ * so an ancestor with no Name at all is a real absent candidate (#4930).
+ */
+export declare function matchParentRule(rule: ParentRule, store: IfcDataStore, expressId: number): boolean;
+//# sourceMappingURL=filter-match.d.ts.map

package/dist/filter/filter-match.d.ts.map

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