@ifc-lite/clash 1.9.2 → 2.1.0

package/dist/index.d.ts

@@ -9,6 +9,7 @@
  */
 export * from './types.js';
 export { matchesSelector } from './selectors.js';
+export { clashMemberKey, clashMemberSet, inClashSet } from './members.js';
 export { DISCIPLINES, CLASH_RULE_PRESETS, inferClashSeverity, disciplineMatrixRules, rulesFromPresets, type Discipline, type DisciplineInfo, type ClashRulePreset, } from './disciplines.js';
 export { createClashEngine, type ClashEngine, type ClashBackend, type CreateClashEngineOptions } from './engine.js';
 export { makeExclusionSet, isExcluded, pairKey, qualifiedKey } from './exclude.js';
@@ -17,7 +18,8 @@ export { groupClashes, isClusterGroupingIneffective, type GroupOptions } from '.
 export { groupDuplicateSets } from './duplicate-sets.js';
 export { clashReviewKey, aggregateReviewStatus, reviewStatusToBcfTopicStatus, } from './review.js';
 export { compareClashRuns, type ClashRevisionDiff } from './lifecycle.js';
-export { SEVERITY_RANK, TOUCHING_EPSILON, penetrationDepth, isTouching, sortClashes, summarizeClashes, ruleHadNoMatch, classifyRuleCoverage, type ClashSortBy, type RuleCoverageOutcome, } from './analysis.js';
+export { compareClashRevisions, type ClashRevisionSide, type ClashRevisionComparison, type ClashRevisionReasons, } from './revision.js';
+export { SEVERITY_RANK, TOUCHING_EPSILON, penetrationDepth, isTouching, sortClashes, summarizeClashes, ruleHadNoMatch, classifyRuleCoverage, describeEmptyRuleSides, type ClashSortBy, type RuleCoverageOutcome, } from './analysis.js';
 export { findDuplicates, DUPLICATES_RULE, type DuplicateOptions, } from './duplicates.js';
 /**
  * Per-triangle mesh analysis, re-exported for consumers outside this package

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,KAAK,wBAAwB,EAAE,MAAM,aAAa,CAAC;AACpH,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACnF,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,EACnB,KAAK,iBAAiB,GACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,4BAA4B,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,4BAA4B,GAC7B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,KAAK,WAAW,EAChB,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,cAAc,EACd,eAAe,EACf,KAAK,gBAAgB,GACtB,MAAM,iBAAiB,CAAC;AACzB;;;;;;;GAOG;AACH,OAAO,EACL,YAAY,EACZ,KAAK,QAAQ,GACd,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,KAAK,wBAAwB,EAAE,MAAM,aAAa,CAAC;AACpH,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACnF,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,EACnB,KAAK,iBAAiB,GACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,4BAA4B,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,4BAA4B,GAC7B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EACL,qBAAqB,EACrB,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC1B,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,WAAW,EAChB,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,cAAc,EACd,eAAe,EACf,KAAK,gBAAgB,GACtB,MAAM,iBAAiB,CAAC;AACzB;;;;;;;GAOG;AACH,OAAO,EACL,YAAY,EACZ,KAAK,QAAQ,GACd,MAAM,uBAAuB,CAAC"}

package/dist/index.js

@@ -12,6 +12,7 @@
  */
 export * from './types.js';
 export { matchesSelector } from './selectors.js';
+export { clashMemberKey, clashMemberSet, inClashSet } from './members.js';
 export { DISCIPLINES, CLASH_RULE_PRESETS, inferClashSeverity, disciplineMatrixRules, rulesFromPresets, } from './disciplines.js';
 export { createClashEngine } from './engine.js';
 export { makeExclusionSet, isExcluded, pairKey, qualifiedKey } from './exclude.js';
@@ -20,7 +21,8 @@ export { groupClashes, isClusterGroupingIneffective } from './grouping.js';
 export { groupDuplicateSets } from './duplicate-sets.js';
 export { clashReviewKey, aggregateReviewStatus, reviewStatusToBcfTopicStatus, } from './review.js';
 export { compareClashRuns } from './lifecycle.js';
-export { SEVERITY_RANK, TOUCHING_EPSILON, penetrationDepth, isTouching, sortClashes, summarizeClashes, ruleHadNoMatch, classifyRuleCoverage, } from './analysis.js';
+export { compareClashRevisions, } from './revision.js';
+export { SEVERITY_RANK, TOUCHING_EPSILON, penetrationDepth, isTouching, sortClashes, summarizeClashes, ruleHadNoMatch, classifyRuleCoverage, describeEmptyRuleSides, } from './analysis.js';
 export { findDuplicates, DUPLICATES_RULE, } from './duplicates.js';
 /**
  * Per-triangle mesh analysis, re-exported for consumers outside this package

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;GAQG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,GAIjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAsE,MAAM,aAAa,CAAC;AACpH,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACnF,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,GAEpB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,4BAA4B,EAAqB,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,4BAA4B,GAC7B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,gBAAgB,EAA0B,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,oBAAoB,GAGrB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,cAAc,EACd,eAAe,GAEhB,MAAM,iBAAiB,CAAC;AACzB;;;;;;;GAOG;AACH,OAAO,EACL,YAAY,GAEb,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;GAQG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,GAIjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAsE,MAAM,aAAa,CAAC;AACpH,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACnF,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,GAEpB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,4BAA4B,EAAqB,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,4BAA4B,GAC7B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,gBAAgB,EAA0B,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EACL,qBAAqB,GAItB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,sBAAsB,GAGvB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,cAAc,EACd,eAAe,GAEhB,MAAM,iBAAiB,CAAC;AACzB;;;;;;;GAOG;AACH,OAAO,EACL,YAAY,GAEb,MAAM,uBAAuB,CAAC"}

package/dist/lifecycle.d.ts

@@ -1,14 +1,3 @@
-/**
- * Clash lifecycle across model revisions (Phase 5).
- *
- * Compares two clash runs and partitions their clashes into added / resolved /
- * persistent buckets. Matching is by the stable `clash.id`, which is durable
- * across revisions because it derives from the elements' durable keys
- * (IfcGUID / USD prim path) plus the rule id — not from runtime refs that
- * change between loads. This makes the diff stable: a clash that survives a
- * revision keeps its id and is reported as `persistent` rather than as a
- * resolve-plus-add churn.
- */
 import type { Clash, ClashResult } from './types.js';
 /**
  * The result of comparing a previous clash run to a later ("next") one.
@@ -17,6 +6,9 @@ import type { Clash, ClashResult } from './types.js';
  * - `persistent` clashes present in both runs (still open; the `next` Clash)
  * - `resolved`   clashes present in `previous` but not in `next` (fixed/removed)
  *
+ * "Present in" counts occurrences, not just review keys: two clashes sharing a
+ * review key in one run need a counterpart each to both be `persistent`.
+ *
  * Each array is sorted by `clash.id` for deterministic, diff-friendly output.
  */
 export interface ClashRevisionDiff {

package/dist/lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../src/lifecycle.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,KAAK,EAAE,CAAC;IACf,UAAU,EAAE,KAAK,EAAE,CAAC;IACpB,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAClE;AAyBD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,GAAG,iBAAiB,CAsC5F"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../src/lifecycle.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,KAAK,EAAE,CAAC;IACf,UAAU,EAAE,KAAK,EAAE,CAAC;IACpB,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAClE;AAsID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,GAAG,iBAAiB,CA8B5F"}

package/dist/lifecycle.js

@@ -1,6 +1,35 @@
 /* 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/. */
+/**
+ * Clash lifecycle across model revisions (Phase 5).
+ *
+ * Compares two clash runs and partitions their clashes into added / resolved /
+ * persistent buckets. Matching is by `clashReviewKey` (review.ts) — the rule id
+ * plus the two elements' durable keys (IfcGUID / USD prim path), order-
+ * independent — NOT by the raw `clash.id`. `clash.id` (`engine-ts/orchestrator.
+ * ts`'s `clashId()`) also folds in `ClashElement.model`, which review.ts
+ * documents as "an ephemeral per-load id in the viewer": two loads of the
+ * identical geometry — exactly the "revision" scenario this module exists to
+ * diff — get two different `model` values and therefore two different
+ * `clash.id`s for the same real-world clash. Matching on the review key keeps
+ * the diff stable across loads: a clash that survives a revision is reported
+ * as `persistent` rather than as a resolve-plus-add churn.
+ *
+ * The review key is NOT unique within a run, and the matching below is built
+ * around that. Dropping `model` is what makes the key durable, but the engine
+ * treats `(model, key)` as element identity — `orchestrator.ts` skips a pair
+ * only when `elA.key === elB.key && elA.model === elB.model` — and
+ * `adapters/ifcx.ts` keys on the bare USD prim path while `adapters/step.ts`
+ * keys on the bare IfcGUID (only its `syntheticKey` fallback folds in the
+ * model id). A federated run gathers every loaded model, so one run can
+ * legitimately hold several DISTINCT clashes under one review key: `/Duct` in
+ * layer-a and `/Duct` in layer-b each hitting the same wall. Matching by key
+ * membership alone would collapse those, silently swallowing a resolved clash
+ * and reporting a genuinely new one as pre-existing, so occurrences are
+ * grouped per key and paired (see `pairGroup`) instead.
+ */
+import { clashReviewKey } from './review.js';
 /** Stable string compare for ids (ASCII/Unicode code-point order). */
 function byId(a, b) {
     if (a.id < b.id)
@@ -10,19 +39,108 @@ function byId(a, b) {
     return 0;
 }
 /**
- * Index a run's clashes by their stable id for O(1) membership checks. The
- * engine dedups clash ids within a run, so ids are unique here. If a caller
- * passed a hand-built run with a repeated id, the map keeps the last occurrence
- * for membership tests, while the added/persistent/resolved buckets below
- * iterate the raw clash arrays — so a duplicate id would appear once per
- * occurrence in its bucket and in the counts.
+ * Group a run's clashes by their durable review key (`clashReviewKey`, not
+ * `clash.id` — see the module docstring), keeping EVERY occurrence rather than
+ * the last one. The key is deliberately not unique within a run (module
+ * docstring), so the group length is the multiplicity that `pairGroup` needs
+ * in order to tell "the same clash, seen again" from "a second, different
+ * clash that happens to share a review key".
  */
-function indexById(run) {
-    const byKey = new Map();
+function groupByReviewKey(run) {
+    const groups = new Map();
+    for (const clash of run.clashes) {
+        const key = clashReviewKey(clash);
+        const group = groups.get(key);
+        if (group)
+            group.push(clash);
+        else
+            groups.set(key, [clash]);
+    }
+    return groups;
+}
+/** Every `model` id that appears on any clash in a run. `toRef`
+ *  (`engine-ts/orchestrator.ts`) carries `model` onto both of a `Clash`'s
+ *  element refs, so this is readable from a `ClashResult` alone. A model that
+ *  produced no clash at all in the run is invisible here — see `pairGroup`. */
+function modelsInRun(run) {
+    const models = new Set();
     for (const clash of run.clashes) {
-        byKey.set(clash.id, clash);
+        models.add(clash.a.model);
+        models.add(clash.b.model);
+    }
+    return models;
+}
+/** True when both of a clash's elements sit in models the other run also
+ *  clashed in, i.e. that clash's `clash.id` was still mintable there. */
+function bothModelsIn(clash, models) {
+    return models.has(clash.a.model) && models.has(clash.b.model);
+}
+/** Split into [matching, rest], preserving run order in both. */
+function partition(clashes, keep) {
+    const yes = [];
+    const no = [];
+    for (const clash of clashes)
+        (keep(clash) ? yes : no).push(clash);
+    return [yes, no];
+}
+/**
+ * Pair one review key's previous-run occurrences against its next-run ones.
+ *
+ * Equal `clash.id`s are paired first. `clashId()` folds both elements' `model`
+ * into the id, so an id match is the same clash between the same two loaded
+ * models — which covers the whole of the "federated session that did not
+ * reload" case, pairing every surviving clash with ITSELF.
+ *
+ * A leftover is the same real-world clash seen again only if `model` was
+ * re-minted between the runs, and the data says whether it was: a previous-run
+ * leftover whose two models BOTH still clash somewhere in the next run was not
+ * re-minted, so had that clash survived it would have produced the same id and
+ * paired above — it is genuinely `resolved`. The mirror of that is genuinely
+ * `added`. Only leftovers whose models the other run no longer shows — the
+ * re-load this whole module exists to diff — are paired with each other, in
+ * run order, and the surplus on either side is `added` / `resolved`. Without
+ * that model test, two runs of one federated session in which the wall stops
+ * hitting `/Duct` in layer-a and starts hitting `/Duct` in layer-b would pair
+ * on count alone: the fixed clash would vanish from `resolved` and the new one
+ * would be reported as pre-existing.
+ *
+ * The model ids are read off the two runs' clashes, so a model that produced
+ * no clash at all in a run is invisible to the test and its clashes count as
+ * re-minted. That errs towards pairing, i.e. towards `persistent`: the
+ * churn-free reading, not a claim that something was fixed.
+ *
+ * `persistent` always receives the NEXT run's Clash (current geometry).
+ */
+function pairGroup(previous, next, models, out) {
+    const prevIndicesById = new Map();
+    previous.forEach((clash, i) => {
+        const slot = prevIndicesById.get(clash.id);
+        if (slot)
+            slot.push(i);
+        else
+            prevIndicesById.set(clash.id, [i]);
+    });
+    const matchedPrev = new Array(previous.length).fill(false);
+    const unmatchedNext = [];
+    for (const clash of next) {
+        const index = prevIndicesById.get(clash.id)?.shift();
+        if (index === undefined) {
+            unmatchedNext.push(clash);
+        }
+        else {
+            matchedPrev[index] = true;
+            out.persistent.push(clash);
+        }
     }
-    return byKey;
+    const unmatchedPrev = previous.filter((_, i) => !matchedPrev[i]);
+    const [reloadedPrev, stillLivePrev] = partition(unmatchedPrev, (clash) => !bothModelsIn(clash, models.next));
+    const [reloadedNext, stillLiveNext] = partition(unmatchedNext, (clash) => !bothModelsIn(clash, models.previous));
+    out.resolved.push(...stillLivePrev);
+    out.added.push(...stillLiveNext);
+    const paired = Math.min(reloadedPrev.length, reloadedNext.length);
+    out.persistent.push(...reloadedNext.slice(0, paired));
+    out.added.push(...reloadedNext.slice(paired));
+    out.resolved.push(...reloadedPrev.slice(paired));
 }
 /**
  * Compare two clash runs and partition their clashes by lifecycle state.
@@ -33,26 +151,18 @@ function indexById(run) {
  * caller can render the up-to-date state. Each array is sorted by id.
  */
 export function compareClashRuns(previous, next) {
-    const prevById = indexById(previous);
-    const nextById = indexById(next);
-    const added = [];
-    const persistent = [];
-    const resolved = [];
-    for (const clash of next.clashes) {
-        if (prevById.has(clash.id)) {
-            // Present in both runs: still open. Report the next run's Clash so the
-            // caller sees current geometry, not the stale previous-revision copy.
-            persistent.push(clash);
-        }
-        else {
-            added.push(clash);
-        }
+    const prevGroups = groupByReviewKey(previous);
+    const nextGroups = groupByReviewKey(next);
+    const models = { previous: modelsInRun(previous), next: modelsInRun(next) };
+    const buckets = { added: [], persistent: [], resolved: [] };
+    for (const [key, nextGroup] of nextGroups) {
+        pairGroup(prevGroups.get(key) ?? [], nextGroup, models, buckets);
     }
-    for (const clash of previous.clashes) {
-        if (!nextById.has(clash.id)) {
-            resolved.push(clash);
-        }
+    for (const [key, prevGroup] of prevGroups) {
+        if (!nextGroups.has(key))
+            buckets.resolved.push(...prevGroup);
     }
+    const { added, persistent, resolved } = buckets;
     added.sort(byId);
     persistent.sort(byId);
     resolved.sort(byId);

package/dist/lifecycle.js.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../src/lifecycle.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAgC/D,sEAAsE;AACtE,SAAS,IAAI,CAAC,CAAQ,EAAE,CAAQ;IAC9B,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE;QAAE,OAAO,CAAC,CAAC,CAAC;IAC3B,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE;QAAE,OAAO,CAAC,CAAC;IAC1B,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,SAAS,CAAC,GAAgB;IACjC,MAAM,KAAK,GAAG,IAAI,GAAG,EAAiB,CAAC;IACvC,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;QAChC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAC7B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAqB,EAAE,IAAiB;IACvE,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;IACrC,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAEjC,MAAM,KAAK,GAAY,EAAE,CAAC;IAC1B,MAAM,UAAU,GAAY,EAAE,CAAC;IAC/B,MAAM,QAAQ,GAAY,EAAE,CAAC;IAE7B,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;QACjC,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;YAC3B,uEAAuE;YACvE,sEAAsE;YACtE,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IAED,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;QACrC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;YAC5B,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjB,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAEpB,OAAO;QACL,KAAK;QACL,UAAU;QACV,QAAQ;QACR,OAAO,EAAE;YACP,KAAK,EAAE,KAAK,CAAC,MAAM;YACnB,UAAU,EAAE,UAAU,CAAC,MAAM;YAC7B,QAAQ,EAAE,QAAQ,CAAC,MAAM;SAC1B;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../src/lifecycle.ts"],"names":[],"mappings":"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"}

package/dist/members.d.ts

@@ -0,0 +1,13 @@
+import type { ClashElement } from './types.js';
+/**
+ * The membership identity of one element: its model plus its `ref`, encoded
+ * with the engine's existing model-qualified scheme (`qualifiedKey`) so there
+ * is one such encoding in this package rather than two.
+ */
+export declare function clashMemberKey(model: string, ref: number): string;
+/** Index a rule's member list; `null` when the side has no explicit members. */
+export declare function clashMemberSet(members: readonly string[] | undefined): ReadonlySet<string> | null;
+/** Whether one element belongs to a rule side, by membership when the side has
+ *  an explicit member set and by type selector otherwise. */
+export declare function inClashSet(element: Pick<ClashElement, 'model' | 'ref' | 'tag'>, selector: string, members: ReadonlySet<string> | null): boolean;
+//# sourceMappingURL=members.d.ts.map

package/dist/members.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"members.d.ts","sourceRoot":"","sources":["../src/members.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,gFAAgF;AAChF,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACrC,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CAE5B;AAED;6DAC6D;AAC7D,wBAAgB,UAAU,CACxB,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,GAAG,KAAK,GAAG,KAAK,CAAC,EACpD,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,GAClC,OAAO,CAGT"}

package/dist/members.js

@@ -0,0 +1,46 @@
+/* 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/. */
+/**
+ * Explicit MEMBERSHIP for a rule's A / B set.
+ *
+ * `ClashRule.a` / `.b` are type-name selectors, and a `ClashElement` carries
+ * nothing but its type (`tag`), name and storey — so a selector cannot express
+ * "walls whose `Pset_WallCommon.IsExternal` is true". A caller that DOES have
+ * the model (the viewer resolves its advanced filter against the parsed store)
+ * resolves such a set to element identities and hands them over as
+ * `membersA` / `membersB`; the engine then partitions by membership instead of
+ * by the selector, and everything downstream — severity, exclusions, dedup,
+ * coverage, both kernels — is untouched.
+ *
+ * The identity is `(model, ref)`, not `key`. `ref` is what a caller holding a
+ * `(modelId, expressId)` pair can compute directly, while `key` is built inside
+ * the adapter out of the stored GlobalId plus an occurrence suffix and cannot
+ * be reconstructed from the store alone. Two GPU-instanced occurrences of one
+ * entity share a `ref` and both land in the set, which is the intended reading
+ * of "this entity is in set A".
+ *
+ * An EMPTY member list is not an absent one — see `ClashRule.membersA`.
+ */
+import { qualifiedKey } from './exclude.js';
+import { matchesSelector } from './selectors.js';
+/**
+ * The membership identity of one element: its model plus its `ref`, encoded
+ * with the engine's existing model-qualified scheme (`qualifiedKey`) so there
+ * is one such encoding in this package rather than two.
+ */
+export function clashMemberKey(model, ref) {
+    return qualifiedKey(model, String(ref));
+}
+/** Index a rule's member list; `null` when the side has no explicit members. */
+export function clashMemberSet(members) {
+    return members ? new Set(members) : null;
+}
+/** Whether one element belongs to a rule side, by membership when the side has
+ *  an explicit member set and by type selector otherwise. */
+export function inClashSet(element, selector, members) {
+    if (members)
+        return members.has(clashMemberKey(element.model, element.ref));
+    return matchesSelector(element.tag, selector);
+}
+//# sourceMappingURL=members.js.map

package/dist/members.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"members.js","sourceRoot":"","sources":["../src/members.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa,EAAE,GAAW;IACvD,OAAO,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;AAC1C,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,cAAc,CAC5B,OAAsC;IAEtC,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAC3C,CAAC;AAED;6DAC6D;AAC7D,MAAM,UAAU,UAAU,CACxB,OAAoD,EACpD,QAAgB,EAChB,OAAmC;IAEnC,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5E,OAAO,eAAe,CAAC,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;AAChD,CAAC"}

package/dist/revision.d.ts

@@ -0,0 +1,68 @@
+import type { Clash, ClashResult } from './types.js';
+/**
+ * One side of a revision comparison: a completed run plus the durable
+ * identity of every model it drew elements from.
+ *
+ * `ClashElementRef.model` (carried on `Clash.a`/`Clash.b`) is the federation's
+ * per-LOAD id — `crypto.randomUUID()` in the viewer — so it is deliberately
+ * useless for asking "is this model still part of the comparison". `modelNames`
+ * is the caller-supplied bridge: a map from that ephemeral id, AS IT APPEARS ON
+ * THIS RESULT'S OWN CLASHES, to a durable identity (the model's display name /
+ * filename in the viewer). Two different `model` ids that map to the same name
+ * are treated as the same model reloaded; a name present in `previous` but
+ * absent from `next` is treated as a model the comparison lost entirely.
+ *
+ * This is a heuristic, not a proof: renaming a model between runs makes it
+ * look "missing" (its old name has no counterpart), and two distinctly loaded
+ * files that happen to share a display name look like one. Both failure modes
+ * point the same way — toward `unretested` rather than a wrongly-confident
+ * `resolved` — which is the direction this module exists to be safe in.
+ */
+export interface ClashRevisionSide {
+    result: ClashResult;
+    /** Ephemeral `ClashElementRef.model` id → durable display identity. */
+    modelNames: Readonly<Record<string, string>>;
+}
+export interface ClashRevisionReasons {
+    /** Rule ids the baseline ran that the current run's `rulesRun` omits entirely. */
+    skippedRuleIds: string[];
+    /** Rule ids the current run ran but whose coverage matched 0 elements on a
+     *  side (`ruleHadNoMatch`) — it ran, but compared nothing. */
+    noMatchRuleIds: string[];
+    /** Durable model names present in the baseline that have no counterpart
+     *  (by name) among the current run's models. */
+    missingModelNames: string[];
+}
+export interface ClashRevisionComparison {
+    /** In the current run, not the baseline: new issues. */
+    added: Clash[];
+    /** In both runs: still open. Carries the current run's `Clash`. */
+    persistent: Clash[];
+    /** In the baseline, not the current run, AND safe to call fixed: every rule
+     *  and model the clash depended on was genuinely re-checked. */
+    resolved: Clash[];
+    /** In the baseline, not the current run, but NOT safe to call fixed: the
+     *  current run could not have found it even if it still existed (a skipped
+     *  rule, an empty-match rule, or a model no longer in the comparison). Never
+     *  silently folded into `resolved`. */
+    unretested: Clash[];
+    /** Why each `unretested` clash landed there, for a coordinator's UI banner. */
+    reasons: ClashRevisionReasons;
+    summary: {
+        added: number;
+        persistent: number;
+        resolved: number;
+        unretested: number;
+    };
+}
+/**
+ * Compare a saved baseline run to a current run, safely.
+ *
+ * Pure and deterministic: depends only on the two inputs. `resolved` only
+ * receives a clash whose rule ran (with real matches on both sides) in the
+ * current run AND whose two models both still have a same-named counterpart
+ * there — everything else that `compareClashRuns` would have called
+ * `resolved` moves to `unretested` instead.
+ */
+export declare function compareClashRevisions(previous: ClashRevisionSide, next: ClashRevisionSide): ClashRevisionComparison;
+//# sourceMappingURL=revision.d.ts.map

package/dist/revision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revision.d.ts","sourceRoot":"","sources":["../src/revision.ts"],"names":[],"mappings":"AAqDA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,WAAW,CAAC;IACpB,uEAAuE;IACvE,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,oBAAoB;IACnC,kFAAkF;IAClF,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB;kEAC8D;IAC9D,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB;oDACgD;IAChD,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,uBAAuB;IACtC,wDAAwD;IACxD,KAAK,EAAE,KAAK,EAAE,CAAC;IACf,mEAAmE;IACnE,UAAU,EAAE,KAAK,EAAE,CAAC;IACpB;oEACgE;IAChE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB;;;2CAGuC;IACvC,UAAU,EAAE,KAAK,EAAE,CAAC;IACpB,+EAA+E;IAC/E,OAAO,EAAE,oBAAoB,CAAC;IAC9B,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;CACtF;AAkGD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,iBAAiB,GACtB,uBAAuB,CAoEzB"}