@ifc-lite/clash 1.1.0

package/dist/disciplines.js

@@ -0,0 +1,148 @@
+/* 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/. */
+/**
+ * BIM discipline definitions, IFC type mappings, and clash rule presets.
+ * Inspired by industry-standard discipline coordination workflows.
+ */
+import { matchesSelector } from './selectors.js';
+export const DISCIPLINES = {
+    ARCH: {
+        code: 'ARCH',
+        label: 'Architectural',
+        selector: 'IfcWall|IfcSlab|IfcRoof|IfcStair|IfcDoor|IfcWindow|IfcCurtainWall|IfcRailing',
+    },
+    STR: {
+        code: 'STR',
+        label: 'Structural',
+        selector: 'IfcBeam|IfcColumn|IfcSlab|IfcFooting|IfcPile|IfcWall',
+    },
+    MEP: {
+        code: 'MEP',
+        label: 'Mechanical / Plumbing',
+        selector: 'IfcPipe*|IfcPump|IfcValve*|IfcTank|IfcFlowTerminal',
+    },
+    HVAC: {
+        code: 'HVAC',
+        label: 'HVAC',
+        selector: 'IfcDuct*|IfcAirTerminal*|IfcUnitaryEquipment|IfcFan',
+    },
+    ELEC: {
+        code: 'ELEC',
+        label: 'Electrical',
+        selector: 'IfcCableSegment|IfcCableFitting|IfcCableCarrierSegment|IfcElectricDistributionBoard|IfcJunctionBox',
+    },
+    FIRE: {
+        code: 'FIRE',
+        label: 'Fire Protection',
+        selector: 'IfcFireSuppressionTerminal|IfcPipe*',
+    },
+    GEO: {
+        code: 'GEO',
+        label: 'Site / Geotechnical',
+        selector: 'IfcSite|IfcGeographicElement|IfcEarthworksElement',
+    },
+};
+export const CLASH_RULE_PRESETS = [
+    {
+        id: 'MEPxSTR',
+        name: 'MEP vs Structure',
+        description: 'Pipes and fittings clashing with beams, columns, and slabs',
+        severity: 'critical',
+        selectorA: 'IfcPipe*|IfcPump|IfcValve*|IfcTank',
+        selectorB: 'IfcBeam|IfcColumn|IfcSlab|IfcFooting',
+    },
+    {
+        id: 'HVACxSTR',
+        name: 'HVAC vs Structure',
+        description: 'Ducts clashing with structural elements',
+        severity: 'critical',
+        selectorA: 'IfcDuct*|IfcAirTerminal*|IfcUnitaryEquipment',
+        selectorB: 'IfcBeam|IfcColumn|IfcSlab',
+    },
+    {
+        id: 'HVACxARCH',
+        name: 'HVAC vs Architecture',
+        description: 'Ducts passing through walls and slabs (penetration sleeves needed)',
+        severity: 'major',
+        selectorA: 'IfcDuct*|IfcAirTerminal*',
+        selectorB: 'IfcWall|IfcSlab|IfcRoof',
+    },
+    {
+        id: 'MEPxARCH',
+        name: 'MEP vs Architecture',
+        description: 'Pipes passing through walls and slabs (penetration sleeves needed)',
+        severity: 'major',
+        selectorA: 'IfcPipe*|IfcPump|IfcValve*',
+        selectorB: 'IfcWall|IfcSlab|IfcRoof',
+    },
+    {
+        id: 'HVACxMEP',
+        name: 'HVAC vs MEP',
+        description: 'Ducts crossing pipes (routing conflicts)',
+        severity: 'major',
+        selectorA: 'IfcDuct*',
+        selectorB: 'IfcPipe*',
+    },
+    {
+        id: 'FIRExSTR',
+        name: 'Fire Protection vs Structure',
+        description: 'Sprinkler pipes clashing with structure',
+        severity: 'critical',
+        selectorA: 'IfcFireSuppressionTerminal|IfcPipe*',
+        selectorB: 'IfcBeam|IfcColumn|IfcSlab',
+    },
+    {
+        id: 'ELECxMEP',
+        name: 'Electrical vs MEP',
+        description: 'Cables too close to pipes (separation rules)',
+        severity: 'minor',
+        selectorA: 'IfcCableSegment|IfcCableFitting|IfcCableCarrierSegment',
+        selectorB: 'IfcPipe*|IfcDuct*',
+    },
+];
+const SEVERITY_ORDER = {
+    critical: 0,
+    major: 1,
+    minor: 2,
+    info: 3,
+};
+/**
+ * Infer severity for a clash from the IFC types of the two elements, by matching
+ * against the discipline-pair presets. Returns the most severe matching rule.
+ */
+export function inferClashSeverity(typeA, typeB) {
+    let best = 'info';
+    for (const preset of CLASH_RULE_PRESETS) {
+        const matchForward = matchesSelector(typeA, preset.selectorA) && matchesSelector(typeB, preset.selectorB);
+        const matchReverse = matchesSelector(typeA, preset.selectorB) && matchesSelector(typeB, preset.selectorA);
+        if ((matchForward || matchReverse) && SEVERITY_ORDER[preset.severity] < SEVERITY_ORDER[best]) {
+            best = preset.severity;
+        }
+    }
+    return best;
+}
+/** Turn the discipline presets into runnable clash rules (the clash matrix). */
+/**
+ * Turn an arbitrary list of rule presets into runnable `ClashRule`s. Used by the
+ * built-in discipline matrix below and by the viewer to run a user-edited preset
+ * set. `clearance` is threaded onto each rule only in clearance mode (narrow.ts
+ * only reports clearance violations when `rule.clearance != null`); `reportTouch`
+ * is threaded onto every rule when set.
+ */
+export function rulesFromPresets(presets, mode = 'hard', clearance, reportTouch) {
+    return presets.map((preset) => ({
+        id: preset.id,
+        name: preset.name,
+        a: preset.selectorA,
+        b: preset.selectorB,
+        mode,
+        severity: preset.severity,
+        ...(mode === 'clearance' && clearance != null ? { clearance } : {}),
+        ...(reportTouch ? { reportTouch: true } : {}),
+    }));
+}
+export function disciplineMatrixRules(mode = 'hard', clearance) {
+    return rulesFromPresets(CLASH_RULE_PRESETS, mode, clearance);
+}
+//# sourceMappingURL=disciplines.js.map

package/dist/disciplines.js.map

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

package/dist/engine-ts/broad.d.ts

@@ -0,0 +1,11 @@
+import type { ClashElement } from '../types.js';
+/**
+ * Broad-phase candidate pairs.
+ *
+ * Group pair (`groupB` provided): each returned `[i, j]` indexes
+ * `groupA[i]` × `groupB[j]`. Self-clash (`groupB === null`): both indices refer
+ * to `groupA`, with `i < j`. Query bounds are inflated by `margin` so clearance
+ * candidates (within the gap) are not missed.
+ */
+export declare function candidatePairs(groupA: ClashElement[], groupB: ClashElement[] | null, margin: number): Array<[number, number]>;
+//# sourceMappingURL=broad.d.ts.map

package/dist/engine-ts/broad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broad.d.ts","sourceRoot":"","sources":["../../src/engine-ts/broad.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,YAAY,EAAE,EACtB,MAAM,EAAE,YAAY,EAAE,GAAG,IAAI,EAC7B,MAAM,EAAE,MAAM,GACb,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAsCzB"}

package/dist/engine-ts/broad.js

@@ -0,0 +1,61 @@
+/* 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/. */
+import { BVH } from '@ifc-lite/spatial';
+import { inflate } from '../math/aabb.js';
+/**
+ * Broad-phase candidate pairs.
+ *
+ * Group pair (`groupB` provided): each returned `[i, j]` indexes
+ * `groupA[i]` × `groupB[j]`. Self-clash (`groupB === null`): both indices refer
+ * to `groupA`, with `i < j`. Query bounds are inflated by `margin` so clearance
+ * candidates (within the gap) are not missed.
+ */
+export function candidatePairs(groupA, groupB, margin) {
+    if (groupA.length === 0)
+        return [];
+    const items = groupA.map((e, i) => ({ bounds: e.bounds, expressId: i }));
+    const bvh = BVH.build(items);
+    const pairs = [];
+    if (groupB) {
+        const seen = new Set();
+        for (let j = 0; j < groupB.length; j += 1) {
+            const b = groupB[j];
+            const hits = bvh.queryAABB(inflate(b.bounds, margin));
+            for (const i of hits) {
+                const a = groupA[i];
+                if (a.key === b.key && a.model === b.model)
+                    continue;
+                const dedup = orderKey(a.model, a.key, b.model, b.key);
+                if (seen.has(dedup))
+                    continue;
+                seen.add(dedup);
+                pairs.push([i, j]);
+            }
+        }
+    }
+    else {
+        for (let i = 0; i < groupA.length; i += 1) {
+            const a = groupA[i];
+            const hits = bvh.queryAABB(inflate(a.bounds, margin));
+            for (const j of hits) {
+                if (j <= i)
+                    continue;
+                const other = groupA[j];
+                // Skip same-entity pairs: an element split across several geometry
+                // sub-prims (common in IFC5/USD) produces multiple elements with the
+                // same durable key — that is one entity, not a self-clash.
+                if (a.key === other.key && a.model === other.model)
+                    continue;
+                pairs.push([i, j]);
+            }
+        }
+    }
+    return pairs;
+}
+function orderKey(modelA, keyA, modelB, keyB) {
+    const a = `${modelA} ${keyA}`;
+    const b = `${modelB} ${keyB}`;
+    return a < b ? `${a} ${b}` : `${b} ${a}`;
+}
+//# sourceMappingURL=broad.js.map

package/dist/engine-ts/broad.js.map

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

package/dist/engine-ts/index.d.ts

@@ -0,0 +1,16 @@
+import type { ClashElement, ClashResult, ClashRule, ClashSettings } from '../types.js';
+export type { ClashKernel, NarrowRecord, RuleDetection } from './kernel.js';
+export { runClash } from './orchestrator.js';
+export { TsKernel } from './ts-kernel.js';
+/** A clash engine: a pure async function of (elements, rules, settings). */
+export interface ClashEngine {
+    run(elements: ClashElement[], rules: ClashRule[], settings?: ClashSettings): Promise<ClashResult>;
+}
+/**
+ * Reference engine: the shared orchestrator driving the pure-TypeScript geometry
+ * kernel (spatial BVH broad phase + exact triangle narrow phase).
+ */
+export declare class TsClashEngine implements ClashEngine {
+    run(elements: ClashElement[], rules: ClashRule[], settings?: ClashSettings): Promise<ClashResult>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/engine-ts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/engine-ts/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIvF,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,QAAQ,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,QAAQ,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CACnG;AAED;;;GAGG;AACH,qBAAa,aAAc,YAAW,WAAW;IAC/C,GAAG,CACD,QAAQ,EAAE,YAAY,EAAE,EACxB,KAAK,EAAE,SAAS,EAAE,EAClB,QAAQ,GAAE,aAAkB,GAC3B,OAAO,CAAC,WAAW,CAAC;CAGxB"}

package/dist/engine-ts/index.js

@@ -0,0 +1,17 @@
+/* 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/. */
+import { runClash } from './orchestrator.js';
+import { TsKernel } from './ts-kernel.js';
+export { runClash } from './orchestrator.js';
+export { TsKernel } from './ts-kernel.js';
+/**
+ * Reference engine: the shared orchestrator driving the pure-TypeScript geometry
+ * kernel (spatial BVH broad phase + exact triangle narrow phase).
+ */
+export class TsClashEngine {
+    run(elements, rules, settings = {}) {
+        return runClash(elements, rules, settings, new TsKernel());
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/engine-ts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/engine-ts/index.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAG/D,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG1C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAO1C;;;GAGG;AACH,MAAM,OAAO,aAAa;IACxB,GAAG,CACD,QAAwB,EACxB,KAAkB,EAClB,WAA0B,EAAE;QAE5B,OAAO,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,QAAQ,EAAE,CAAC,CAAC;IAC7D,CAAC;CACF"}

package/dist/engine-ts/kernel.d.ts

@@ -0,0 +1,50 @@
+import type { AABB, ClashElement, ClashRule, ClashStatus, Vec3 } from '../types.js';
+/**
+ * One detected clash, in kernel terms: a pair of GLOBAL element indices plus the
+ * geometric verdict. The orchestrator turns this into a `Clash` (identity,
+ * severity, exclusions). This is the seam between orchestration (shared, pure
+ * TypeScript) and the geometry kernel (TypeScript today, Rust/WASM in Phase 3).
+ */
+export interface NarrowRecord {
+    /** Global index into the ingested `elements` array. */
+    a: number;
+    /** Global index into the ingested `elements` array. */
+    b: number;
+    status: ClashStatus;
+    distance: number;
+    point: Vec3;
+    bounds: AABB;
+}
+export interface RuleDetection {
+    records: NarrowRecord[];
+    /** Candidate pairs actually examined — drives the run-global `maxPairs` budget. */
+    candidatesProcessed: number;
+    /** Candidate pairs skipped by the `maxPairs` cap (for transparency). */
+    candidatesDropped: number;
+}
+/**
+ * The geometry backend: broad phase + narrow phase for one rule. Implementations
+ * must be interchangeable — given the same elements and rule they produce the
+ * same records (modulo floating-point), which is what the differential test
+ * pins. Selection, exclusions, severity and identity live in the orchestrator,
+ * never here.
+ */
+export interface ClashKernel {
+    /** Ingest the elements once (build any indices). */
+    prepare(elements: ClashElement[]): void;
+    /**
+     * Detect clashes for one rule. `groupA`/`groupB` are GLOBAL element indices;
+     * `groupB === null` means a self-clash within `groupA`. Returned records carry
+     * GLOBAL element indices. `maxPairs` caps candidate pairs (Infinity = no cap).
+     */
+    detectRule(elements: ClashElement[], groupA: number[], groupB: number[] | null, rule: ClashRule, tolerance: number, maxPairs: number, signal?: AbortSignal, 
+    /**
+     * Reports narrow-phase progress as `(processedPairs, totalPairs)`. The TS
+     * kernel calls it periodically AND yields to the event loop between calls,
+     * so a long run on the main thread stays responsive and can paint progress.
+     */
+    onProgress?: (done: number, total: number) => void): RuleDetection | Promise<RuleDetection>;
+    /** Release any resources (e.g. a WASM session). Optional. */
+    dispose?(): void;
+}
+//# sourceMappingURL=kernel.d.ts.map

package/dist/engine-ts/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../src/engine-ts/kernel.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEpF;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,CAAC,EAAE,MAAM,CAAC;IACV,uDAAuD;IACvD,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,IAAI,CAAC;IACZ,MAAM,EAAE,IAAI,CAAC;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,mFAAmF;IACnF,mBAAmB,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,oDAAoD;IACpD,OAAO,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;IACxC;;;;OAIG;IACH,UAAU,CACR,QAAQ,EAAE,YAAY,EAAE,EACxB,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EACvB,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,WAAW;IACpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GACjD,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAC1C,6DAA6D;IAC7D,OAAO,CAAC,IAAI,IAAI,CAAC;CAClB"}

package/dist/engine-ts/kernel.js

@@ -0,0 +1,5 @@
+/* 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 {};
+//# sourceMappingURL=kernel.js.map

package/dist/engine-ts/kernel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.js","sourceRoot":"","sources":["../../src/engine-ts/kernel.ts"],"names":[],"mappings":"AAAA;;+DAE+D"}

package/dist/engine-ts/narrow.d.ts

@@ -0,0 +1,23 @@
+import type { AABB, ClashElement, ClashRule, ClashStatus, Vec3 } from '../types.js';
+import type { TriMesh } from './tri-mesh.js';
+export interface NarrowResult {
+    status: ClashStatus;
+    distance: number;
+    point: Vec3;
+    bounds: AABB;
+}
+/**
+ * Narrow-phase test for one candidate element pair.
+ *
+ * Gathers candidate triangle pairs through the per-element triangle BVHs (work
+ * stays proportional to actual overlap — no decimation), then:
+ * - a genuine non-coplanar triangle crossing ⇒ `hard` (pipe through beam, etc.);
+ * - surfaces that merely coincide/touch (no crossing) are disambiguated by AABB
+ *   penetration, so a deep axis-aligned overlap — whose surface intersections
+ *   are all coplanar — is still classified `hard`, while face contact is `touch`;
+ * - otherwise the exact triangle distance drives `clearance` / `touch` / no clash.
+ *
+ * Returns `null` for no clash.
+ */
+export declare function testPair(elA: ClashElement, triA: TriMesh, elB: ClashElement, triB: TriMesh, rule: ClashRule, tolerance: number): NarrowResult | null;
+//# sourceMappingURL=narrow.d.ts.map

package/dist/engine-ts/narrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"narrow.d.ts","sourceRoot":"","sources":["../../src/engine-ts/narrow.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAKpF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,IAAI,CAAC;IACZ,MAAM,EAAE,IAAI,CAAC;CACd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CACtB,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,MAAM,GAChB,YAAY,GAAG,IAAI,CAgHrB"}

package/dist/engine-ts/narrow.js

@@ -0,0 +1,127 @@
+/* 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/. */
+import { aabbContains, boundsOfPoints, center, inflate, overlapBounds, signedGap } from '../math/aabb.js';
+import { centroid, mid } from '../math/vec3.js';
+import { triTriIntersect } from '../math/triangle-intersect.js';
+import { triTriDistance } from '../math/triangle-distance.js';
+/**
+ * Narrow-phase test for one candidate element pair.
+ *
+ * Gathers candidate triangle pairs through the per-element triangle BVHs (work
+ * stays proportional to actual overlap — no decimation), then:
+ * - a genuine non-coplanar triangle crossing ⇒ `hard` (pipe through beam, etc.);
+ * - surfaces that merely coincide/touch (no crossing) are disambiguated by AABB
+ *   penetration, so a deep axis-aligned overlap — whose surface intersections
+ *   are all coplanar — is still classified `hard`, while face contact is `touch`;
+ * - otherwise the exact triangle distance drives `clearance` / `touch` / no clash.
+ *
+ * Returns `null` for no clash.
+ */
+export function testPair(elA, triA, elB, triB, rule, tolerance) {
+    const margin = Math.max(tolerance, rule.clearance ?? 0);
+    // Iterate the smaller mesh, querying the larger one's BVH.
+    const aSmaller = triA.count <= triB.count;
+    const small = aSmaller ? triA : triB;
+    const large = aSmaller ? triB : triA;
+    let intersects = false;
+    let contactSumX = 0;
+    let contactSumY = 0;
+    let contactSumZ = 0;
+    let contactN = 0;
+    let minDist = Infinity;
+    let closestA = elA.bounds.min;
+    let closestB = elB.bounds.min;
+    for (let ts = 0; ts < small.count; ts += 1) {
+        const sb = small.triBounds(ts);
+        const hits = large.queryTris(inflate(sb, margin));
+        if (hits.length === 0)
+            continue;
+        const [s0, s1, s2] = small.tri(ts);
+        for (const tl of hits) {
+            const [l0, l1, l2] = large.tri(tl);
+            if (triTriIntersect(s0, s1, s2, l0, l1, l2)) {
+                intersects = true;
+                const c = mid(centroid(s0, s1, s2), centroid(l0, l1, l2));
+                contactSumX += c[0];
+                contactSumY += c[1];
+                contactSumZ += c[2];
+                contactN += 1;
+            }
+            else if (!intersects) {
+                // Distance only matters while we still might be a clearance/touch case.
+                const d = triTriDistance(s0, s1, s2, l0, l1, l2);
+                if (d.dist < minDist) {
+                    minDist = d.dist;
+                    closestA = d.pA;
+                    closestB = d.pB;
+                }
+            }
+        }
+    }
+    const overlap = overlapBounds(elA.bounds, elB.bounds);
+    if (intersects) {
+        const point = contactN > 0
+            ? [contactSumX / contactN, contactSumY / contactN, contactSumZ / contactN]
+            : center(overlap);
+        // Phase-0 penetration estimate from AABB overlap; exact depth lands in Rust.
+        const penetration = Math.max(0, -signedGap(elA.bounds, elB.bounds));
+        return { status: 'hard', distance: -penetration, point, bounds: overlap };
+    }
+    // Fully-enclosed solid: no surface crossing, but one element's AABB is wholly
+    // inside the other's, so it may be buried (e.g. equipment inside a slab). With
+    // no surface crossing the inner solid is entirely inside OR entirely outside
+    // the other, so ray-casting ONE representative vertex of the contained mesh
+    // against the other solid decides it — and ray casting (not an AABB test)
+    // correctly returns "outside" when the inner sits in a concave notch.
+    // Test B-contains-A first, then A-contains-B, so the inner pick is
+    // deterministic (and identical to the Rust kernel) on equal AABBs.
+    if (aabbContains(elB.bounds, elA.bounds)) {
+        if (triA.count > 0 && triB.containsPoint(triA.tri(0)[0])) {
+            return { status: 'hard', distance: signedGap(elA.bounds, elB.bounds), point: center(overlap), bounds: overlap };
+        }
+    }
+    else if (aabbContains(elA.bounds, elB.bounds)) {
+        if (triB.count > 0 && triA.containsPoint(triB.tri(0)[0])) {
+            return { status: 'hard', distance: signedGap(elA.bounds, elB.bounds), point: center(overlap), bounds: overlap };
+        }
+    }
+    if (minDist === Infinity) {
+        // Broad-phase candidate with no triangle-level proximity — not a clash.
+        return null;
+    }
+    // Surfaces coincide/touch with no genuine crossing, but the volumes overlap
+    // beyond tolerance (e.g. axis-aligned boxes, whose surface intersections are
+    // all coplanar) -> hard, via AABB penetration depth.
+    if (minDist <= tolerance) {
+        const gap = signedGap(elA.bounds, elB.bounds);
+        if (gap < -tolerance) {
+            return { status: 'hard', distance: gap, point: center(overlap), bounds: overlap };
+        }
+    }
+    // Clearance rule: ANY gap within the required clearance is a violation —
+    // including sub-tolerance, nearly-touching gaps, which are the MOST severe and
+    // must not be swallowed by the touch band below.
+    if (rule.mode === 'clearance' && rule.clearance != null && minDist <= rule.clearance) {
+        return {
+            status: 'clearance',
+            distance: minDist,
+            point: mid(closestA, closestB),
+            bounds: boundsOfPoints(closestA, closestB),
+        };
+    }
+    // Otherwise only bare contact within tolerance remains; suppressed unless the
+    // rule opts in. `<=` so an exact touch at tolerance 0 is still caught.
+    if (minDist <= tolerance) {
+        if (!rule.reportTouch)
+            return null;
+        return {
+            status: 'touch',
+            distance: minDist,
+            point: mid(closestA, closestB),
+            bounds: boundsOfPoints(closestA, closestB),
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=narrow.js.map

package/dist/engine-ts/narrow.js.map

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

package/dist/engine-ts/orchestrator.d.ts

@@ -0,0 +1,11 @@
+import { type ClashElement, type ClashResult, type ClashRule, type ClashSettings } from '../types.js';
+import type { ClashKernel } from './kernel.js';
+/**
+ * Backend-agnostic clash orchestration: selection, exclusions, severity, stable
+ * identity, dedup, ordering and summary. The geometry (broad + narrow phase) is
+ * delegated to a `ClashKernel` (TypeScript or Rust/WASM), so swapping backends
+ * changes nothing observable except speed — which is exactly what makes the two
+ * engines differentially comparable.
+ */
+export declare function runClash(elements: ClashElement[], rules: ClashRule[], settings: ClashSettings, kernel: ClashKernel): Promise<ClashResult>;
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/engine-ts/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/engine-ts/orchestrator.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,YAAY,EAEjB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,aAAa,EAGnB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAC5B,QAAQ,EAAE,YAAY,EAAE,EACxB,KAAK,EAAE,SAAS,EAAE,EAClB,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,WAAW,CAAC,CAoGtB"}