wabachi 0.1.0

package/dist/runtime/correlation.js

@@ -0,0 +1,919 @@
+import { createHash } from "node:crypto";
+const MAX_CANDIDATE_PAIRS_PER_KEY = 100_000;
+const RULE_ORDER = [
+    "same-repository-revision",
+    "same-path",
+    "same-range",
+    "same-kind",
+    "same-qualified-name",
+    "same-alias",
+    "same-name",
+    "same-signature",
+];
+/**
+ * Converts provider paths to a repository-relative, slash-separated form.
+ * This intentionally does not consult the host filesystem.
+ */
+export function normalizeRepositoryPath(value) {
+    const parts = [];
+    for (const part of value.trim().replaceAll("\\", "/").split("/")) {
+        if (part.length === 0 || part === ".")
+            continue;
+        if (part === "..") {
+            if (parts.length > 0 && parts[parts.length - 1] !== "..")
+                parts.pop();
+            continue;
+        }
+        parts.push(part);
+    }
+    return parts.join("/") || ".";
+}
+/**
+ * Converts common TypeScript/Graft (`L1C1-L1C4`), SCIP (`0:0-0:3`), and
+ * packed SCIP ranges to the same one-based representation.
+ */
+export function normalizeSourceRange(value, providerId = "", rangeBase) {
+    if (value === undefined)
+        return undefined;
+    if (isNumberArray(value)) {
+        if (value.length !== 3 && value.length !== 4)
+            return undefined;
+        const numbers = value.map((part) => Number(part));
+        if (numbers.some((part) => !Number.isInteger(part) || part < 0))
+            return undefined;
+        const zeroBased = (rangeBase ?? defaultRangeBase(providerId)) === "zero-based";
+        const [startLine, startColumn, endLine, endColumn] = numbers.length === 3 ? [numbers[0], numbers[1], numbers[0], numbers[2]] : numbers;
+        return makeRange(startLine, startColumn, endLine, endColumn, zeroBased);
+    }
+    if (typeof value === "object") {
+        if (!Number.isInteger(value.startLine) ||
+            value.startLine < 1 ||
+            !Number.isInteger(value.endLine) ||
+            value.endLine < 1 ||
+            (value.startColumn !== undefined && (!Number.isInteger(value.startColumn) || value.startColumn < 1)) ||
+            (value.endColumn !== undefined && (!Number.isInteger(value.endColumn) || value.endColumn < 1))) {
+            return undefined;
+        }
+        return { ...value };
+    }
+    const text = value.trim();
+    const labelled = /^L(\d+)(?:C(\d+))?(?:-L?(\d+)(?:C(\d+))?)?$/iu.exec(text);
+    if (labelled) {
+        const startLine = Number(labelled[1]);
+        const startColumn = labelled[2] === undefined ? undefined : Number(labelled[2]);
+        const endLine = labelled[3] === undefined ? startLine : Number(labelled[3]);
+        const endColumn = labelled[4] === undefined ? undefined : Number(labelled[4]);
+        return makeRange(startLine, startColumn, endLine, endColumn, false);
+    }
+    const numeric = /^(\d+):(\d+)-(\d+):(\d+)$/u.exec(text);
+    if (numeric) {
+        const zeroBased = (rangeBase ?? defaultRangeBase(providerId)) === "zero-based";
+        return makeRange(Number(numeric[1]), Number(numeric[2]), Number(numeric[3]), Number(numeric[4]), zeroBased);
+    }
+    return undefined;
+}
+function defaultRangeBase(providerId) {
+    return providerId === "scip-typescript" || providerId === "scip" ? "zero-based" : "one-based";
+}
+function makeRange(startLine, startColumn, endLine, endColumn, zeroBased) {
+    const lineOffset = zeroBased ? 1 : 0;
+    const columnOffset = zeroBased ? 1 : 0;
+    const normalized = {
+        startLine: startLine + lineOffset,
+        endLine: endLine + lineOffset,
+        ...(startColumn === undefined ? {} : { startColumn: startColumn + columnOffset }),
+        ...(endColumn === undefined ? {} : { endColumn: endColumn + columnOffset }),
+    };
+    if (normalized.startLine > normalized.endLine)
+        return undefined;
+    if (normalized.startLine === normalized.endLine &&
+        normalized.startColumn !== undefined &&
+        normalized.endColumn !== undefined &&
+        normalized.startColumn > normalized.endColumn) {
+        return undefined;
+    }
+    return normalized;
+}
+/** Correlates provider-native entities using only deterministic local rules. */
+export function correlateProviderEntities(inputs) {
+    const entities = normalizeEntities(inputs);
+    const candidateBuild = buildCandidateEdges(entities);
+    const edges = candidateBuild.edges;
+    const edgeIndex = indexEdges(edges, entities);
+    const groups = buildGroups(entities, edges);
+    const entityGroup = new Map();
+    for (const group of groups) {
+        for (const index of group.indices)
+            entityGroup.set(index, group);
+    }
+    const canonicalIds = new Map();
+    for (const group of groups) {
+        canonicalIds.set(group, makeCanonicalId(group, entities));
+    }
+    const links = edges.map((edge) => toCorrelationLink(edge, entities, edgeIndex)).sort(compareLinks);
+    const canonicalEntities = groups
+        .map((group) => {
+        const canonicalId = canonicalIds.get(group);
+        if (canonicalId === undefined)
+            throw new Error("internal correlation group has no identity");
+        return toCanonicalEntity(group, canonicalId, entities, edgeIndex, entityGroup, canonicalIds);
+    })
+        .sort((left, right) => left.canonicalId.localeCompare(right.canonicalId));
+    return {
+        canonicalEntities,
+        links,
+        metrics: buildMetrics(entities, edgeIndex, groups, entityGroup, canonicalIds),
+        diagnostics: candidateBuild.diagnostics,
+    };
+}
+/** Short alias for callers that already have provider entities. */
+export const correlateEntities = correlateProviderEntities;
+/** Extracts definition/structural entities from the existing Observation envelope. */
+export function providerEntitiesFromObservations(observations) {
+    return extractProviderEntities(observations, true);
+}
+/**
+ * Extracts every endpoint represented by observations. Definitions are still
+ * preferred by the fact normalizer, but relation-only endpoints (for example
+ * call sites) must remain available when no definition observation exists.
+ */
+export function providerEntitiesFromAllObservations(observations) {
+    return extractProviderEntities(observations, false);
+}
+function extractProviderEntities(observations, preferDefinitions) {
+    const byProvider = new Map();
+    for (const observation of observations) {
+        const key = providerKey(observation.provider);
+        const list = byProvider.get(key) ?? [];
+        list.push(observation);
+        byProvider.set(key, list);
+    }
+    const entities = [];
+    for (const providerObservations of byProvider.values()) {
+        const hasDefinitions = providerObservations.some((observation) => observation.predicate === "defines");
+        for (const observation of providerObservations) {
+            if (preferDefinitions && hasDefinitions && observation.predicate !== "defines")
+                continue;
+            const endpoints = [];
+            if (observation.predicate === "defines") {
+                if (isObservationEntity(observation.object)) {
+                    endpoints.push(observation.object);
+                }
+                else {
+                    endpoints.push(observation.subject);
+                }
+            }
+            else {
+                endpoints.push(observation.subject);
+                if (isObservationEntity(observation.object))
+                    endpoints.push(observation.object);
+            }
+            for (const endpoint of endpoints) {
+                entities.push(toProviderEntityInput(observation, endpoint));
+            }
+        }
+    }
+    return entities;
+}
+/** Correlates the provider-native entities represented by observations. */
+export function correlateObservations(observations) {
+    return correlateProviderEntities(providerEntitiesFromObservations(observations));
+}
+function toProviderEntityInput(observation, endpoint) {
+    const native = asRecord(observation.providerNative);
+    const nativeNode = asRecord(native?.node);
+    const sourceNode = asRecord(native?.sourceNode);
+    const targetNode = asRecord(native?.targetNode);
+    const endpointNode = [sourceNode, targetNode, nativeNode].find((candidate) => stringValue(candidate?.id) === endpoint.id);
+    const nativeRecord = endpointNode ?? nativeNode ?? native;
+    const nativeId = stringValue(nativeRecord?.id);
+    const endpointIsNode = nativeId === endpoint.id;
+    const pathValue = (endpointIsNode ? stringValue(nativeRecord?.path) : undefined) ?? observation.source.path;
+    const spanValue = (endpointIsNode ? stringValue(nativeRecord?.span) : undefined) ?? observation.source.span;
+    const nativeName = endpointIsNode ? stringValue(nativeRecord?.name) : undefined;
+    const nativeQualifiedName = endpointIsNode ? stringValue(nativeRecord?.qualifiedName) : undefined;
+    const nativeSignature = endpointIsNode
+        ? (stringValue(nativeRecord?.signature) ?? stringValue(nativeRecord?.type))
+        : undefined;
+    const nativeAliases = endpointIsNode ? stringArray(nativeRecord?.aliases) : [];
+    const inferredName = nativeName ?? lastSymbolPart(nativeQualifiedName ?? endpoint.id);
+    return {
+        provider: observation.provider,
+        repository: observation.repository,
+        id: endpoint.id,
+        kind: endpoint.kind,
+        path: pathValue,
+        span: spanValue,
+        name: inferredName,
+        qualifiedName: nativeQualifiedName ?? endpoint.id,
+        signature: nativeSignature,
+        aliases: nativeAliases,
+        providerNative: observation.providerNative,
+    };
+}
+function isObservationEntity(value) {
+    const record = asRecord(value);
+    return record !== undefined && typeof record.id === "string" && typeof record.kind === "string";
+}
+function normalizeEntities(inputs) {
+    const normalized = inputs.map((input) => {
+        const pathValue = input.path ?? input.source?.path;
+        const spanValue = input.range ?? input.span ?? input.source?.span;
+        const pathNormalized = pathValue === undefined ? undefined : normalizeRepositoryPath(pathValue);
+        const rangeNormalized = normalizeSourceRange(spanValue, input.provider.id, input.rangeBase);
+        const aliases = uniqueSorted((input.aliases ?? []).map((alias) => alias.trim()).filter((alias) => alias.length > 0));
+        const qualifiedName = cleanOptional(input.qualifiedName);
+        const name = cleanOptional(input.name);
+        const signature = cleanOptional(input.signature);
+        const qualifiedKeys = uniqueSorted(qualifiedName === undefined ? [] : symbolKeys(qualifiedName));
+        const aliasKeys = uniqueSorted(aliases.flatMap((alias) => symbolKeys(alias)));
+        const nameKeys = uniqueSorted([
+            ...(name === undefined ? [] : symbolKeys(name)),
+            ...(qualifiedName === undefined ? [] : symbolKeys(qualifiedName)),
+            ...aliasKeys,
+        ]);
+        const signatureKey = signature === undefined ? undefined : normalizeSignature(signature);
+        const kind = cleanOptional(input.kind) ?? "unknown";
+        const kindFamily = kindFamilyOf(kind);
+        const providerKeyValue = providerKey(input.provider);
+        const repositoryKeyValue = repositoryKey(input.repository);
+        const id = input.id.trim();
+        const key = stableSerialize({
+            provider: providerKeyValue,
+            repository: repositoryKeyValue,
+            id,
+            kind: kindFamily,
+            path: pathNormalized,
+            range: rangeNormalized,
+            name: nameKeys,
+            qualifiedName: qualifiedKeys,
+            aliases: aliasKeys,
+            signature: signatureKey,
+        });
+        return {
+            input,
+            providerKey: providerKeyValue,
+            repositoryKey: repositoryKeyValue,
+            id,
+            kind,
+            kindFamily,
+            path: pathNormalized,
+            range: rangeNormalized,
+            name,
+            qualifiedName,
+            signature,
+            aliases,
+            qualifiedKeys,
+            aliasKeys,
+            nameKeys,
+            signatureKey,
+            key,
+        };
+    });
+    normalized.sort(compareEntities);
+    const deduplicated = [];
+    for (const entity of normalized) {
+        const previous = deduplicated[deduplicated.length - 1];
+        if (previous?.key !== entity.key) {
+            deduplicated.push(entity);
+            continue;
+        }
+        // The provider-native payload is not part of identity. Choosing the
+        // lexicographically first payload keeps duplicate observations stable.
+        if (stableSerialize(entity.input.providerNative) < stableSerialize(previous.input.providerNative)) {
+            deduplicated[deduplicated.length - 1] = entity;
+        }
+    }
+    return deduplicated;
+}
+function compareEntities(left, right) {
+    const keyCompare = left.key.localeCompare(right.key);
+    if (keyCompare !== 0)
+        return keyCompare;
+    return stableSerialize(left.input.providerNative).localeCompare(stableSerialize(right.input.providerNative));
+}
+function buildCandidateEdges(entities) {
+    const buckets = new Map();
+    for (let index = 0; index < entities.length; index += 1) {
+        for (const key of candidateKeys(entities[index])) {
+            const bucket = buckets.get(key) ?? [];
+            bucket.push(index);
+            buckets.set(key, bucket);
+        }
+    }
+    const pairKeys = new Set();
+    const skippedByClass = new Map();
+    let indexedKeyCount = 0;
+    let globalPairCount = 0;
+    let globalCapExceeded = false;
+    for (const [key, bucket] of buckets.entries()) {
+        const potentialPairCount = (bucket.length * (bucket.length - 1)) / 2;
+        if (potentialPairCount > MAX_CANDIDATE_PAIRS_PER_KEY) {
+            const keyClass = key.split(":", 1)[0] ?? "unknown";
+            const current = skippedByClass.get(keyClass) ?? { keyCount: 0, potentialPairCount: 0 };
+            current.keyCount += 1;
+            current.potentialPairCount += potentialPairCount;
+            skippedByClass.set(keyClass, current);
+            continue;
+        }
+        indexedKeyCount += 1;
+        for (let left = 0; left < bucket.length; left += 1) {
+            for (let right = left + 1; right < bucket.length; right += 1) {
+                if (globalCapExceeded)
+                    continue;
+                const first = bucket[left];
+                const second = bucket[right];
+                const low = Math.min(first, second);
+                const high = Math.max(first, second);
+                const pairKey = `${low}\u0000${high}`;
+                if (!pairKeys.has(pairKey)) {
+                    if (globalPairCount >= MAX_CANDIDATE_PAIRS_PER_KEY) {
+                        globalCapExceeded = true;
+                        const keyClass = key.split(":", 1)[0] ?? "unknown";
+                        const current = skippedByClass.get(keyClass) ?? { keyCount: 0, potentialPairCount: 0 };
+                        current.keyCount += 1;
+                        current.potentialPairCount += potentialPairCount;
+                        skippedByClass.set(keyClass, current);
+                        continue;
+                    }
+                    pairKeys.add(pairKey);
+                    globalPairCount += 1;
+                }
+            }
+        }
+    }
+    const edges = [];
+    for (const pairKey of pairKeys) {
+        const separator = pairKey.indexOf("\u0000");
+        const left = Number(pairKey.slice(0, separator));
+        const right = Number(pairKey.slice(separator + 1));
+        const edge = compareEntityPair(left, right, entities[left], entities[right]);
+        if (edge !== undefined)
+            edges.push(edge);
+    }
+    const skippedKeys = [...skippedByClass.entries()]
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+        .map(([keyClass, value]) => ({ keyClass, ...value }));
+    return {
+        edges: edges.sort(compareEdges),
+        diagnostics: {
+            maxCandidatePairsPerKey: MAX_CANDIDATE_PAIRS_PER_KEY,
+            indexedKeyCount,
+            skippedKeyCount: skippedKeys.reduce((count, item) => count + item.keyCount, 0),
+            skippedPotentialPairCount: skippedKeys.reduce((count, item) => count + item.potentialPairCount, 0),
+            skippedKeys,
+        },
+    };
+}
+/**
+ * Candidate generation is indexed by every rule that can make
+ * `compareEntityPair` return a score. The final pair comparison remains the
+ * authority, so these keys only avoid evaluating impossible pairs.
+ */
+function candidateKeys(entity) {
+    const keys = new Set();
+    if (entity.path !== undefined && entity.range !== undefined) {
+        keys.add(`path-range:${entity.path}:${stableSerialize(entity.range)}`);
+    }
+    if (entity.path !== undefined && entity.signatureKey !== undefined) {
+        keys.add(`path-signature:${entity.path}:${entity.signatureKey}`);
+    }
+    if (entity.signatureKey !== undefined)
+        keys.add(`signature:${entity.signatureKey}`);
+    if (entity.qualifiedName !== undefined) {
+        keys.add(`qualified-exact:${entity.qualifiedName}`);
+        keys.add(`alias-match-exact:${entity.qualifiedName}`);
+    }
+    for (const qualifiedKey of entity.qualifiedKeys) {
+        keys.add(`qualified-normalized:${qualifiedKey}`);
+    }
+    for (const alias of entity.aliases)
+        keys.add(`alias-match-exact:${alias}`);
+    for (const aliasKey of entity.aliasKeys) {
+        keys.add(`alias-normalized:${aliasKey}`);
+    }
+    for (const nameKey of entity.nameKeys) {
+        if (entity.path !== undefined) {
+            keys.add(`path-name-normalized:${entity.path}:${nameKey}`);
+        }
+    }
+    // A bare token such as "type" or "0" is not a useful cross-file
+    // candidate key. Exact names remain useful when the source path also
+    // agrees, while the final pair comparison still computes all rules.
+    if (entity.path !== undefined && entity.name !== undefined) {
+        keys.add(`path-name-exact:${entity.path}:${entity.name}`);
+    }
+    if (entity.path !== undefined &&
+        entity.name === undefined &&
+        entity.qualifiedName === undefined &&
+        entity.aliases.length === 0) {
+        keys.add(`path-kind:${entity.path}:${entity.kindFamily}`);
+    }
+    return [...keys].sort();
+}
+function indexEdges(edges, entities) {
+    const incident = new Map();
+    const targets = new Map();
+    const addIncident = (index, edge) => {
+        const values = incident.get(index) ?? [];
+        values.push(edge);
+        incident.set(index, values);
+    };
+    const addTarget = (index, provider, target) => {
+        const byProvider = targets.get(index) ?? new Map();
+        const values = byProvider.get(provider) ?? new Set();
+        values.add(target);
+        byProvider.set(provider, values);
+        targets.set(index, byProvider);
+    };
+    for (const edge of edges) {
+        addIncident(edge.left, edge);
+        addIncident(edge.right, edge);
+        addTarget(edge.left, entities[edge.right].providerKey, edge.right);
+        addTarget(edge.right, entities[edge.left].providerKey, edge.left);
+    }
+    for (const values of incident.values())
+        values.sort(compareEdges);
+    return { incident, targets };
+}
+function uniqueEdges(edges) {
+    const byKey = new Map();
+    for (const edge of edges)
+        byKey.set(`${edge.left}\u0000${edge.right}`, edge);
+    return [...byKey.values()].sort(compareEdges);
+}
+function compareEntityPair(left, right, first, second) {
+    if (first.providerKey === second.providerKey || first.repositoryKey !== second.repositoryKey)
+        return undefined;
+    if (!kindCompatible(first.kindFamily, second.kindFamily))
+        return undefined;
+    const samePath = first.path !== undefined && first.path === second.path;
+    const sameRange = rangesEqual(first.range, second.range);
+    const sameKind = first.kindFamily === second.kindFamily;
+    const sameQualifiedName = intersects(first.qualifiedKeys, second.qualifiedKeys);
+    const sameAlias = intersects(first.aliasKeys, second.aliasKeys) ||
+        intersects(first.aliasKeys, second.qualifiedKeys) ||
+        intersects(first.qualifiedKeys, second.aliasKeys);
+    const sameName = intersects(first.nameKeys, second.nameKeys);
+    const sameSignature = first.signatureKey !== undefined && second.signatureKey !== undefined && first.signatureKey === second.signatureKey;
+    const rules = ["same-repository-revision"];
+    if (samePath)
+        rules.push("same-path");
+    if (sameRange)
+        rules.push("same-range");
+    if (sameKind)
+        rules.push("same-kind");
+    if (sameQualifiedName)
+        rules.push("same-qualified-name");
+    if (sameAlias)
+        rules.push("same-alias");
+    if (sameName)
+        rules.push("same-name");
+    if (sameSignature)
+        rules.push("same-signature");
+    let score;
+    if (samePath && sameRange) {
+        score = 100;
+    }
+    else if ((sameQualifiedName || sameAlias) && kindCompatible(first.kindFamily, second.kindFamily)) {
+        score = 86 + (samePath ? 4 : 0) + (sameSignature ? 3 : 0);
+    }
+    else if (samePath && sameSignature && kindCompatible(first.kindFamily, second.kindFamily)) {
+        score = 82;
+    }
+    else if (samePath && sameName && kindCompatible(first.kindFamily, second.kindFamily)) {
+        score = 68;
+    }
+    else if (sameSignature && kindCompatible(first.kindFamily, second.kindFamily)) {
+        score = 58;
+    }
+    else if (samePath && sameKind && first.nameKeys.length === 0 && second.nameKeys.length === 0) {
+        score = 45;
+    }
+    else if (sameName && kindCompatible(first.kindFamily, second.kindFamily)) {
+        score = 48;
+    }
+    if (score === undefined)
+        return undefined;
+    return {
+        left,
+        right,
+        score,
+        strength: score >= 80 ? "matched" : "probable",
+        rules: sortRules(rules),
+    };
+}
+function buildGroups(entities, edges) {
+    const assigned = new Set();
+    const blocked = new Set();
+    const groups = [];
+    // Consume evidence from strongest to weakest. This preserves overloads:
+    // exact declaration locations are grouped before a shared qualified name
+    // can connect every overload to every other overload.
+    const scores = [...new Set(edges.map((edge) => edge.score))].sort((left, right) => right - left);
+    for (const score of scores) {
+        const eligible = new Set();
+        for (let index = 0; index < entities.length; index += 1) {
+            if (!assigned.has(index) && !blocked.has(index))
+                eligible.add(index);
+        }
+        const scoreEdges = edges.filter((edge) => edge.score === score && eligible.has(edge.left) && eligible.has(edge.right));
+        for (const component of connectedComponents(entities.length, scoreEdges, eligible)) {
+            if (component.length < 2)
+                continue;
+            if (hasProviderCollision(component, entities)) {
+                for (const index of component)
+                    blocked.add(index);
+                continue;
+            }
+            const group = { indices: component, strength: score >= 80 ? "matched" : "probable" };
+            groups.push(group);
+            for (const index of component)
+                assigned.add(index);
+        }
+    }
+    for (let index = 0; index < entities.length; index += 1) {
+        if (!assigned.has(index)) {
+            groups.push({ indices: [index], strength: "probable" });
+        }
+    }
+    return groups.sort((left, right) => entities[left.indices[0]].key.localeCompare(entities[right.indices[0]].key));
+}
+function connectedComponents(entityCount, edges, eligible) {
+    const adjacency = Array.from({ length: entityCount }, () => []);
+    for (const edge of edges) {
+        adjacency[edge.left].push(edge.right);
+        adjacency[edge.right].push(edge.left);
+    }
+    const visited = new Set();
+    const components = [];
+    for (const start of [...eligible].sort((left, right) => left - right)) {
+        if (visited.has(start) || adjacency[start].length === 0)
+            continue;
+        const stack = [start];
+        const component = [];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (current === undefined || visited.has(current))
+                continue;
+            visited.add(current);
+            component.push(current);
+            for (const next of adjacency[current].slice().sort((left, right) => right - left)) {
+                if (!visited.has(next))
+                    stack.push(next);
+            }
+        }
+        components.push(component.sort((left, right) => left - right));
+    }
+    return components.sort((left, right) => left[0] - right[0]);
+}
+function hasProviderCollision(indices, entities) {
+    const providers = new Set(indices.map((index) => entities[index].providerKey));
+    return providers.size !== indices.length;
+}
+function makeCanonicalId(group, entities) {
+    const repository = entities[group.indices[0]].repositoryKey;
+    const members = group.indices.map((index) => entities[index].key).sort();
+    const digest = createHash("sha256").update(stableSerialize({ repository, members })).digest("hex");
+    return `ce_${digest}`;
+}
+function toCanonicalEntity(group, canonicalId, entities, edgeIndex, entityGroup, canonicalIds) {
+    const members = group.indices.map((index) => toCanonicalMember(entities[index])).sort(compareMembers);
+    const groupIndices = new Set(group.indices);
+    const incidentEdges = uniqueEdges(group.indices.flatMap((index) => edgeIndex.incident.get(index) ?? []));
+    const internalEdges = incidentEdges.filter((edge) => groupIndices.has(edge.left) && groupIndices.has(edge.right));
+    const candidateCanonicalIds = uniqueSorted(incidentEdges
+        .flatMap((edge) => {
+        const other = groupIndices.has(edge.left) ? edge.right : edge.left;
+        const otherGroup = entityGroup.get(other);
+        const otherId = otherGroup === undefined ? undefined : canonicalIds.get(otherGroup);
+        return otherId === undefined || otherId === canonicalId ? [] : [otherId];
+    })
+        .filter((id) => id !== undefined));
+    const status = group.indices.length > 1
+        ? group.strength === "matched"
+            ? "matched"
+            : "probable"
+        : incidentEdges.length > 0
+            ? "ambiguous"
+            : "unmatched";
+    const cardinality = groupCardinality(group, incidentEdges, edgeIndex, entities, groupIndices);
+    const reason = status === "unmatched"
+        ? "no-cross-provider-evidence"
+        : status === "ambiguous"
+            ? cardinality === "one-to-many" || cardinality === "many-to-one" || cardinality === "many-to-many"
+                ? "provider-cardinality-conflict"
+                : "competing-evidence"
+            : status === "probable"
+                ? "probable-evidence"
+                : "deterministic-evidence";
+    const evidence = internalEdges.length > 0 ? internalEdges : incidentEdges;
+    const rules = sortRules(uniqueRules(evidence.flatMap((edge) => edge.rules)));
+    const repository = entities[group.indices[0]].input.repository;
+    return {
+        canonicalId,
+        identity: canonicalId,
+        repository,
+        kind: canonicalKind(group.indices.map((index) => entities[index].kindFamily)),
+        status,
+        members,
+        candidateCanonicalIds,
+        rationale: {
+            method: "deterministic-rules",
+            reason,
+            cardinality,
+            rules,
+            evidence: evidence.map((edge) => toEvidence(edge, entities)).sort(compareEvidence),
+        },
+    };
+}
+function toCanonicalMember(entity) {
+    return {
+        provider: entity.input.provider,
+        nativeId: entity.id,
+        kind: entity.kind,
+        canonicalKind: entity.kindFamily,
+        repository: entity.input.repository,
+        ...(entity.path === undefined ? {} : { path: entity.path }),
+        ...(entity.range === undefined ? {} : { range: entity.range }),
+        ...(entity.name === undefined ? {} : { name: entity.name }),
+        ...(entity.qualifiedName === undefined ? {} : { qualifiedName: entity.qualifiedName }),
+        ...(entity.signature === undefined ? {} : { signature: entity.signature }),
+        aliases: entity.aliases,
+        providerNative: entity.input.providerNative,
+    };
+}
+function toEvidence(edge, entities) {
+    return {
+        left: toReference(entities[edge.left]),
+        right: toReference(entities[edge.right]),
+        score: edge.score,
+        rules: edge.rules,
+    };
+}
+function toCorrelationLink(edge, entities, edgeIndex) {
+    return {
+        left: toReference(entities[edge.left]),
+        right: toReference(entities[edge.right]),
+        score: edge.score,
+        strength: edge.strength,
+        cardinality: edgeCardinality(edge, edgeIndex, entities),
+        rules: edge.rules,
+    };
+}
+function toReference(entity) {
+    return {
+        provider: entity.input.provider,
+        nativeId: entity.id,
+        kind: entity.kind,
+        ...(entity.path === undefined ? {} : { path: entity.path }),
+        ...(entity.range === undefined ? {} : { range: entity.range }),
+    };
+}
+function edgeCardinality(edge, edgeIndex, entities) {
+    const leftTargets = edgeIndex.targets.get(edge.left)?.get(entities[edge.right].providerKey) ?? new Set();
+    const rightTargets = edgeIndex.targets.get(edge.right)?.get(entities[edge.left].providerKey) ?? new Set();
+    if (leftTargets.size > 1 && rightTargets.size > 1)
+        return "many-to-many";
+    if (leftTargets.size > 1)
+        return "one-to-many";
+    if (rightTargets.size > 1)
+        return "many-to-one";
+    return "one-to-one";
+}
+function groupCardinality(group, incidentEdges, edgeIndex, entities, groupIndices) {
+    if (incidentEdges.length === 0)
+        return "unmatched";
+    let oneToMany = false;
+    let manyToOne = false;
+    let manyToMany = false;
+    for (const edge of incidentEdges) {
+        const cardinality = edgeCardinality(edge, edgeIndex, entities);
+        if (cardinality === "many-to-many")
+            manyToMany = true;
+        if (cardinality === "one-to-many") {
+            if (groupIndices.has(edge.left))
+                oneToMany = true;
+            if (groupIndices.has(edge.right))
+                manyToOne = true;
+        }
+        if (cardinality === "many-to-one") {
+            if (groupIndices.has(edge.left))
+                oneToMany = true;
+            if (groupIndices.has(edge.right))
+                manyToOne = true;
+        }
+    }
+    if (manyToMany || (oneToMany && manyToOne))
+        return "many-to-many";
+    if (oneToMany)
+        return "one-to-many";
+    if (manyToOne)
+        return "many-to-one";
+    return "one-to-one";
+}
+function buildMetrics(entities, edgeIndex, groups, entityGroup, canonicalIds) {
+    const providerEntries = new Map();
+    for (let index = 0; index < entities.length; index += 1) {
+        const entity = entities[index];
+        const key = entity.input.provider.id;
+        const entry = providerEntries.get(key) ?? { provider: entity.input.provider, indices: [] };
+        entry.indices.push(index);
+        providerEntries.set(key, entry);
+    }
+    const result = {};
+    for (const key of [...providerEntries.keys()].sort()) {
+        const entry = providerEntries.get(key);
+        if (entry === undefined)
+            continue;
+        const statusCounts = {
+            matched: 0,
+            probable: 0,
+            ambiguous: 0,
+            unmatched: 0,
+        };
+        const canonicalEntityIds = new Set();
+        let candidateCount = 0;
+        for (const index of entry.indices) {
+            const group = entityGroup.get(index);
+            if (group !== undefined) {
+                const canonicalId = canonicalIds.get(group);
+                if (canonicalId !== undefined)
+                    canonicalEntityIds.add(canonicalId);
+            }
+            const incident = edgeIndex.incident.get(index) ?? [];
+            candidateCount += incident.length;
+            const status = group === undefined
+                ? "unmatched"
+                : group.indices.length > 1
+                    ? group.strength
+                    : incident.length > 0
+                        ? "ambiguous"
+                        : "unmatched";
+            statusCounts[status] += 1;
+        }
+        result[key] = {
+            provider: entry.provider,
+            total: entry.indices.length,
+            canonicalEntityCount: canonicalEntityIds.size,
+            candidateCount,
+            matched: statusCounts.matched,
+            probable: statusCounts.probable,
+            ambiguous: statusCounts.ambiguous,
+            unmatched: statusCounts.unmatched,
+        };
+    }
+    return result;
+}
+function compareLinks(left, right) {
+    const providerCompare = providerReferenceKey(left.left).localeCompare(providerReferenceKey(right.left));
+    if (providerCompare !== 0)
+        return providerCompare;
+    return providerReferenceKey(left.right).localeCompare(providerReferenceKey(right.right));
+}
+function compareEdges(left, right) {
+    if (left.left !== right.left)
+        return left.left - right.left;
+    if (left.right !== right.right)
+        return left.right - right.right;
+    return right.score - left.score;
+}
+function compareEvidence(left, right) {
+    const leftCompare = providerReferenceKey(left.left).localeCompare(providerReferenceKey(right.left));
+    if (leftCompare !== 0)
+        return leftCompare;
+    return providerReferenceKey(left.right).localeCompare(providerReferenceKey(right.right));
+}
+function compareMembers(left, right) {
+    return providerReferenceKey(left).localeCompare(providerReferenceKey(right));
+}
+function providerReferenceKey(reference) {
+    return stableSerialize({
+        provider: providerKey(reference.provider),
+        nativeId: reference.nativeId,
+        kind: reference.kind,
+        path: reference.path,
+        range: reference.range,
+    });
+}
+function providerKey(provider) {
+    return `${provider.id}\u0000${provider.version}\u0000${provider.determinism}`;
+}
+function repositoryKey(repository) {
+    return stableSerialize({ source: repository.source, commitSha: repository.commitSha });
+}
+function kindFamilyOf(kind) {
+    const normalized = kind.toLowerCase().replace(/[\s_-]/gu, "");
+    if (/(function|method|callable)/u.test(normalized))
+        return "callable";
+    if (/(class|constructor)/u.test(normalized))
+        return "class";
+    if (/(interface)/u.test(normalized))
+        return "interface";
+    if (/(typealias|typedef|type)/u.test(normalized))
+        return "type";
+    if (/(enum)/u.test(normalized))
+        return "enum";
+    if (/(variable|constant|const)/u.test(normalized))
+        return "variable";
+    if (/(property|field|member)/u.test(normalized))
+        return "property";
+    if (/(module|file|sourcefile)/u.test(normalized))
+        return "module";
+    if (/(symbol|declaration|unknown)/u.test(normalized))
+        return "symbol";
+    return normalized || "symbol";
+}
+function canonicalKind(kinds) {
+    const unique = uniqueSorted(kinds);
+    const specific = unique.filter((kind) => kind !== "symbol");
+    if (specific.length === 1)
+        return specific[0];
+    return unique.length === 1 ? unique[0] : "symbol";
+}
+function kindCompatible(left, right) {
+    return left === right || left === "symbol" || right === "symbol";
+}
+function rangesEqual(left, right) {
+    if (left === undefined || right === undefined)
+        return false;
+    return (left.startLine === right.startLine &&
+        left.startColumn === right.startColumn &&
+        left.endLine === right.endLine &&
+        left.endColumn === right.endColumn);
+}
+function normalizeSignature(value) {
+    return value
+        .trim()
+        .replace(/\s+/gu, " ")
+        .replace(/\s*([(),:;<>[\]{}|&=])\s*/gu, "$1");
+}
+function symbolKeys(value) {
+    const normalized = value.trim().replace(/["']/gu, "");
+    if (normalized.length === 0)
+        return [];
+    const keys = new Set([normalized]);
+    const parts = normalized.split(/[^A-Za-z0-9_$]+/u).filter((part) => part.length > 0);
+    for (const part of parts)
+        keys.add(part);
+    return [...keys];
+}
+function lastSymbolPart(value) {
+    const keys = symbolKeys(value);
+    return keys.length === 0 ? undefined : keys[keys.length - 1];
+}
+function intersects(left, right) {
+    const rightSet = new Set(right);
+    return left.some((value) => rightSet.has(value));
+}
+function sortRules(rules) {
+    const ruleSet = new Set(rules);
+    return RULE_ORDER.filter((rule) => ruleSet.has(rule));
+}
+function uniqueRules(rules) {
+    return [...new Set(rules)];
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function cleanOptional(value) {
+    const cleaned = value?.trim();
+    return cleaned === undefined || cleaned.length === 0 ? undefined : cleaned;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((part) => typeof part === "string") : [];
+}
+function isNumberArray(value) {
+    return Array.isArray(value);
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stableSerialize(value) {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return JSON.stringify(value);
+    if (typeof value === "bigint")
+        return `${value.toString()}n`;
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
+    if (typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableSerialize(record[key])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(String(value));
+}
+//# sourceMappingURL=correlation.js.map