@cplieger/deadset-ts 5.2.2 → 6.0.0

package/dist/src/findings/emitters.js

@@ -68,16 +68,40 @@ function dialsOver(input, found, suppressed, unmarked) {
     };
 }
 /**
- * Every finding of one run swept under its suppressions' marks, decided in one pass: every
- * family's findings completed by one step, so every component number is minted once, a
- * pending finding's among them; the finding each record claims withheld, whatever its
- * kind; the rest withheld by the dials, so a root one family reports withholds what
- * another family reports in its component; and every declared edge evaluated over what
- * remains, so a finding it holds pending is in its evaluation and nowhere else.
+ * Every finding of one run swept under its suppressions' marks, decided in one pass: each
+ * family's findings completed by one step, so every component number is minted once, the
+ * finding each record claims withheld, the rest withheld by the dials, so a root one family
+ * reports withholds what another reports in its component, and every declared edge
+ * evaluated over what remains, so a pending finding is in its evaluation alone. What the
+ * minimum confidence withheld is what the same decision at the lowest minimum adds.
  */
 export function decidedFindings(input, suppressed = { unmarked: input, records: [] }) {
     const found = completedOver(input);
     const unmarked = suppressed.records.length === 0 ? [] : completedOver(suppressed.unmarked, fallenMembers);
+    const would = [...unmarked, ...found];
+    const decided = dialledOver(input, suppressed, found, unmarked);
+    const shown = input.config.analysis.minConfidence === "possible"
+        ? decided
+        : dialledOver(atPossible(input), {
+            unmarked: atPossible(suppressed.unmarked),
+            records: suppressed.records,
+        }, found, unmarked);
+    return { ...decided, would, withheld: withheldOf(decided.findings, shown.findings) };
+}
+/** The run's input with the minimum confidence at its lowest, which withholds nothing. */
+function atPossible(input) {
+    const { config } = input;
+    return {
+        ...input,
+        config: { ...config, analysis: { ...config.analysis, minConfidence: "possible" } },
+    };
+}
+/**
+ * The run's completed findings decided under its dials: the finding each record claims
+ * withheld, the rest withheld by the dials, and every declared edge evaluated over what
+ * remains.
+ */
+function dialledOver(input, suppressed, found, unmarked) {
     const would = [...unmarked, ...found];
     const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
     const unanswered = heldRefs(input);
@@ -87,12 +111,23 @@ export function decidedFindings(input, suppressed = { unmarked: input, records:
         !markup.has(finding.symbol.ref) &&
         !insideSkipped(input.swept.skipped, finding.position)));
     const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
-    return {
-        findings: evaluated.findings,
-        evaluations: evaluated.evaluations,
-        ledger,
-        would,
-    };
+    return { findings: evaluated.findings, evaluations: evaluated.evaluations, ledger };
+}
+/** The findings the lowest minimum would report that the run does not, counted by confidence. */
+function withheldOf(reported, shown) {
+    const kept = new Set(reported.map(findingKey));
+    const counts = { certain: 0, probable: 0, possible: 0 };
+    for (const finding of shown) {
+        if (!kept.has(findingKey(finding))) {
+            counts[finding.confidence] += 1;
+        }
+    }
+    return counts;
+}
+/** A finding's identity across two decisions of one run: its position, code and subject. */
+function findingKey(finding) {
+    const { path, line, column } = finding.position;
+    return JSON.stringify([path, line, column, finding.code, finding.symbol.ref]);
 }
 /** Every finding the run reports, each family's in table order. */
 export function findingsOf(input) {

package/dist/src/findings/interfaces.js

@@ -54,15 +54,16 @@ function findingOf(code, symbol, message, implementations) {
  * The findings of the interfaces family, `DS1200` to `DS1299`: `DS1201`, a dead
  * interface, whose members fall with it unreported; and `DS1203`, a method of a live
  * interface no reference names, unless it is a marker, a method whose every
- * implementation has an empty body. A test file's declaration is neither kind's
- * subject, because a production sweep counts none of the references it can have.
+ * implementation has an empty body. A test file's declaration is neither kind's subject,
+ * because a production sweep counts none of the references it can have, save an interface
+ * the run that counts test references does not reach, which is `DS1201`'s.
  */
 export const interfaces = (input) => {
     const run = indexed(input);
     const found = [];
     for (const candidate of input.swept.sweep.candidates) {
         const symbol = run.symbolOf(candidate.id);
-        if (symbol === undefined || run.inTest(candidate.id)) {
+        if (symbol === undefined || (run.inTest(candidate.id) && !candidate.unreferencedTest)) {
             continue;
         }
         if (symbol.kind === "interface") {

package/dist/src/findings/intra-function.js

@@ -14,6 +14,19 @@ function overlapClause(overlap) {
         ? "no other rule is known to report it"
         : `also reported by ${spelled(overlap)}`;
 }
+/**
+ * Whether one parameter's name is reported: every unread one of a function whose
+ * signature is free, and of a function used as a value only one no read parameter follows,
+ * because a caller may pass such a function more arguments than it declares.
+ */
+function parameterReported(part, free, freeButValued) {
+    const place = part.parameter;
+    if (place?.inValue !== true && free.has(part.declaration)) {
+        return true;
+    }
+    const valued = place?.inValue === true || freeButValued.has(part.declaration);
+    return valued && place?.beforeARead !== true;
+}
 /**
  * Whether one part is reported. A parameter needs its function's signature free to
  * change; a result needs that, every call in the loaded program to discard it, and every
@@ -25,10 +38,10 @@ function reported(input, part, callersUnknown) {
     if (part.used) {
         return false;
     }
-    const { free, discardedEverywhere } = input.intraFunction;
+    const { free, freeButValued, discardedEverywhere } = input.intraFunction;
     switch (part.code) {
         case UNUSED_PARAMETER:
-            return free.has(part.declaration);
+            return parameterReported(part, free, freeButValued);
         case UNUSED_RESULT:
             return (free.has(part.declaration) &&
                 discardedEverywhere.has(part.declaration) &&

package/dist/src/findings/unused-declarations.js

@@ -49,9 +49,14 @@ function codeOf(judged) {
     if (candidate.testOfDeadCode) {
         return "DS1005";
     }
-    if (judged.test || judged.containerDead || NOT_THIS_FAMILY.has(symbol.kind)) {
+    if ((judged.test && !candidate.unreferencedTest) ||
+        judged.containerDead ||
+        NOT_THIS_FAMILY.has(symbol.kind)) {
         return undefined;
     }
+    if (candidate.unreferencedTest) {
+        return unreferencedCode(symbol);
+    }
     const referenced = candidate.productionRefs + candidate.testRefs > 0;
     if (symbol.kind === "enum-member" && !referenced) {
         return undefined;
@@ -73,6 +78,13 @@ function codeOf(judged) {
     }
     return judged.unreachable ? undefined : "DS1001";
 }
+/** The code a declaration nothing references carries, by its shape and its visibility. */
+function unreferencedCode(symbol) {
+    if (MEMBERS.has(symbol.kind)) {
+        return "DS1003";
+    }
+    return symbol.exported ? "DS1001" : "DS1002";
+}
 /** The visibility a member's message names, where it narrows the member's reach. */
 function visibilityWord(symbol) {
     switch (symbol.visibility) {

package/dist/src/findings-pass.js

@@ -55,6 +55,7 @@ export function findingsPass(inputs) {
             reasonsRecorded: counts.reasonsRecorded,
             staleSuppressions: records.length,
             pending: decided.evaluations.filter((one) => one.finding !== undefined).length,
+            withheld: decided.withheld,
         },
         ledger,
     };

package/dist/src/graph.js

@@ -32,11 +32,11 @@ const SWEPT = {
 };
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
- * tool reads the configuration it loads and the files its strings name, a runtime runs a
- * test file, a setup file, a worker, a page's module script, a command and a script, the
- * manifest names what enters the package, an alias global stands for the export it names,
- * and an entry file, a configured root and a pattern assert a caller. A library's
- * published API only supposes an unseen consumer, so it is live under reachability alone.
+ * tool reads what it loads and what its strings name, a runtime runs a test, setup or
+ * worker file, a page's module script, a command, a script or a workflow step, the manifest
+ * names what enters the package, an alias global stands for its export, and an entry file,
+ * a configured root and a pattern assert a caller. A library's published API only supposes
+ * an unseen consumer, so it is live under reachability alone.
  */
 const NAMES_A_CALLER = {
     "entry-file": true,
@@ -52,10 +52,10 @@ const NAMES_A_CALLER = {
     "configuration-file": true,
     "configuration-string": true,
     "test-runner": true,
-    "mutation-testing": true,
     "browser-tests": true,
     worker: true,
     "html-entry": true,
+    "workflow-step": true,
 };
 /** Whether the sweep judges a declaration of one kind. */
 export function swept(kind) {

package/dist/src/implementations.js

@@ -54,7 +54,7 @@ function typesAt(project, nodes) {
     return typeAt;
 }
 /** Whether one class member is a method whose every written body holds no statement. */
-function emptyImplementation(project, member) {
+export function emptyImplementation(project, member) {
     const own = project.ownPaths();
     let bodies = 0;
     for (const handle of member.declarations) {

package/dist/src/indexed-access.js

@@ -0,0 +1,215 @@
+/**
+ * The members an indexed-access type names. `T["a" | "b"]` reads the members `a` and `b`
+ * of `T` as a property access by either name would. Where the index is a type parameter
+ * a call fixes, the call names the members the literal type argument names, written or
+ * inferred, which is read off the parameter the type parameter annotates whole. The type
+ * query of a type-query alias is no reference.
+ */
+import { isArrowFunction, isCallExpression, isFunctionDeclaration, isFunctionExpression, isIdentifier, isIndexedAccessTypeNode, isLiteralTypeNode, isMethodDeclaration, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedTypeNode, isPropertyAccessExpression, isStringLiteral, isTypeReferenceNode, isUnionTypeNode, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+import { UNANSWERED } from "./query.js";
+import { typeQueryAliases } from "./type-query-alias.js";
+function isGeneric(node) {
+    return ((isFunctionDeclaration(node) ||
+        isMethodDeclaration(node) ||
+        isArrowFunction(node) ||
+        isFunctionExpression(node)) &&
+        node.typeParameters !== undefined);
+}
+function unwrappedType(node) {
+    return isParenthesizedTypeNode(node) ? unwrappedType(node.type) : node;
+}
+/** The names a literal index type spells, or none where the index is any other type. */
+function literalNames(index) {
+    const node = unwrappedType(index);
+    if (isUnionTypeNode(node)) {
+        const names = node.types.map(literalNames);
+        return names.every((one) => one !== undefined) ? names.flat() : undefined;
+    }
+    if (!isLiteralTypeNode(node)) {
+        return undefined;
+    }
+    const literal = node.literal;
+    if (isStringLiteral(literal) || isNoSubstitutionTemplateLiteral(literal)) {
+        return [literal.text];
+    }
+    return isNumericLiteral(literal) ? [String(Number(literal.text))] : undefined;
+}
+/** The name a literal type carries, a union's each, or none where a constituent is no literal. */
+function literalTypeNames(type, parts) {
+    const names = [];
+    for (const part of parts(type)) {
+        if (part.isStringLiteralType()) {
+            names.push(part.value);
+        }
+        else if (part.isNumberLiteralType()) {
+            names.push(String(part.value));
+        }
+        else {
+            return undefined;
+        }
+    }
+    return names;
+}
+/**
+ * The references the indexed-access types of one project's own files make to the members
+ * they name, each made by the declaration that holds the type or the call, or by the file.
+ */
+export function indexedAccessReferences(project, held, chains, root, testFiles) {
+    const queries = project.queries;
+    const accesses = [];
+    const generics = new Map();
+    const calls = [];
+    const names = new Set();
+    for (const file of project.ownSourceFiles()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId === undefined) {
+            continue;
+        }
+        const aliasTypes = new Set(typeQueryAliases(file).map((alias) => alias.type));
+        const visit = (node, from, enclosing) => {
+            const own = held.declarations.get(nodeKey(file, node));
+            const holder = own ?? from;
+            const inside = isGeneric(node) ? [...enclosing, node] : enclosing;
+            if (isIndexedAccessTypeNode(node) && !aliasTypes.has(node)) {
+                const literal = literalNames(node.indexType);
+                if (literal !== undefined) {
+                    accesses.push({ file, from: holder, at: node, object: node.objectType, names: literal });
+                }
+                else {
+                    parameterIndex(node, inside, file, generics, names);
+                }
+            }
+            if (isCallExpression(node) || isNewExpression(node)) {
+                const callee = node.expression;
+                const name = isIdentifier(callee)
+                    ? callee.text
+                    : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
+                        ? callee.name.text
+                        : undefined;
+                if (name !== undefined) {
+                    calls.push({ file, from: holder, call: node, name });
+                }
+            }
+            node.forEachChild((child) => {
+                visit(child, holder, inside);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, fileId, []);
+        });
+    }
+    for (const { file, from, call, name } of calls) {
+        if (!names.has(name)) {
+            continue;
+        }
+        const resolved = queries.resolvedSignature(call);
+        if (resolved === UNANSWERED || resolved?.declaration === undefined) {
+            continue;
+        }
+        const declaration = project.declarationAt(resolved.declaration)?.node;
+        const byParameter = declaration === undefined
+            ? undefined
+            : generics.get(nodeKey(declaration.getSourceFile(), declaration));
+        if (byParameter === undefined) {
+            continue;
+        }
+        for (const { object, parameter } of byParameter) {
+            const fixed = queries.typeAtPosition(resolved, parameter);
+            const literal = fixed === UNANSWERED ? undefined : literalTypeNames(fixed, (type) => partsOf(type));
+            if (literal !== undefined) {
+                accesses.push({ file, from, at: call, object, names: literal });
+            }
+        }
+    }
+    function partsOf(type) {
+        const parts = queries.constituents(type);
+        return parts === UNANSWERED ? [type] : parts;
+    }
+    const objectNodes = accesses.flatMap((one) => ("kind" in one.object ? [one.object] : []));
+    const typeOf = new Map();
+    queries.typesAt(objectNodes).forEach((answer, index) => {
+        const node = objectNodes[index];
+        if (answer !== UNANSWERED && answer !== undefined && node !== undefined) {
+            typeOf.set(node, answer);
+        }
+    });
+    const found = [];
+    for (const access of accesses) {
+        const type = "kind" in access.object ? typeOf.get(access.object) : access.object;
+        if (type === undefined) {
+            continue;
+        }
+        const position = renderPosition(access.file, root, access.at.getStart());
+        for (const part of partsOf(type)) {
+            const properties = queries.propertiesOf(part);
+            if (properties === UNANSWERED) {
+                continue;
+            }
+            for (const property of properties) {
+                if (!access.names.includes(property.escapedName)) {
+                    continue;
+                }
+                for (const to of chains.declarationsOf(property)) {
+                    found.push({
+                        from: access.from,
+                        to,
+                        position,
+                        use: "read",
+                        resolution: "batch",
+                        test: testFiles.has(position.path),
+                    });
+                }
+            }
+        }
+    }
+    return found;
+}
+/**
+ * Records an indexed-access type whose index names a type parameter of an enclosing
+ * function that a parameter of that function is annotated with whole, so a call's
+ * argument for that parameter fixes the index.
+ */
+function parameterIndex(node, enclosing, file, generics, names) {
+    const index = unwrappedType(node.indexType);
+    if (!isTypeReferenceNode(index) || !isIdentifier(index.typeName)) {
+        return;
+    }
+    const spelled = index.typeName.text;
+    for (const generic of [...enclosing].reverse()) {
+        const declares = (generic.typeParameters ?? []).some((parameter) => isIdentifier(parameter.name) && parameter.name.text === spelled);
+        if (!declares) {
+            continue;
+        }
+        const at = generic.parameters.findIndex((parameter) => {
+            const type = parameter.type === undefined ? undefined : unwrappedType(parameter.type);
+            return (type !== undefined &&
+                isTypeReferenceNode(type) &&
+                isIdentifier(type.typeName) &&
+                type.typeName.text === spelled);
+        });
+        if (at >= 0) {
+            const key = nodeKey(file, generic);
+            generics.set(key, [...(generics.get(key) ?? []), { object: node.objectType, parameter: at }]);
+            const name = calledName(generic);
+            if (name !== undefined) {
+                names.add(name);
+            }
+        }
+        return;
+    }
+}
+/** The name a call writes to call one generic function: its own, or its variable's. */
+function calledName(generic) {
+    const own = generic.name;
+    if (own !== undefined && isIdentifier(own)) {
+        return own.text;
+    }
+    const parent = generic.parent;
+    return parent.kind === SyntaxKind.VariableDeclaration &&
+        parent.name !== undefined &&
+        isIdentifier(parent.name)
+        ? parent.name.text
+        : undefined;
+}

package/dist/src/interface-satisfaction.js

@@ -1,20 +1,15 @@
 /**
- * The interface-satisfaction class: a class member is held back when a value of the
- * class reaches a position the checker types as an interface requiring a member of
- * that name, so a caller reaches the member through the interface while no name in
- * the program resolves to it.
- *
- * A value reaches such a position as an `implements` entry, the initializer of a
- * declaration whose type is written, an assignment, an argument, a returned value, an
- * array element, an object property, or the operand of `as` or `satisfies`, read
- * through parentheses, conditionals and the operators whose result is an operand.
- * `this` in an instance member is a value of its class. Types are asked in batches;
- * the contextual lookup has none, so it is asked only of a value whose type is a class
- * of the target, and each distinct pair, interface and class is asked once.
+ * The interface-satisfaction class: a member is held back when a value of its class
+ * reaches a position the checker types as an interface requiring that member, through an
+ * `implements` entry, a typed initializer, an assignment, an argument, a return, an array
+ * element, an object property or an `as` or `satisfies` operand. `this` is a value of its
+ * class, and a position typed by a type parameter reaches its constraint. The contextual
+ * lookup has no batch form, so it is asked only of a value typed as a target class.
  */
-import { isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isHeritageClause, isMethodDeclaration, isObjectLiteralExpression, isSetAccessorDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isHeritageClause, isMethodDeclaration, isNewExpression, isObjectLiteralExpression, isSetAccessorDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.js";
+import { emptyImplementation } from "./implementations.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must } from "./query.js";
@@ -153,6 +148,10 @@ export function interfaceSatisfaction(input) {
     const interfaceNames = new Map();
     /** The interface types one position's type is or holds, each with the interface's name. */
     const interfacesOf = (type) => partsOf(type).flatMap((part) => {
+        if (part.isTypeParameter()) {
+            const constraint = must(queries.constraintOf(part));
+            return constraint === undefined ? [] : interfacesOf(constraint);
+        }
         if (!interfaceNames.has(part.id)) {
             const symbol = part.isObjectType() ? must(queries.symbolOfType(part)) : undefined;
             interfaceNames.set(part.id, symbol !== undefined && (symbol.flags & SymbolFlags.Interface) !== 0
@@ -162,6 +161,21 @@ export function interfaceSatisfaction(input) {
         const name = interfaceNames.get(part.id);
         return name === undefined ? [] : [{ type: part, name }];
     });
+    /**
+     * The type an argument's parameter declares in the generic signature a call
+     * instantiates, which is a type parameter where the argument is a type argument's value:
+     * the contextual type of such an argument is the instantiation, not the parameter.
+     */
+    const genericPosition = (value) => {
+        const call = value.parent;
+        if (!isCallExpression(call) && !isNewExpression(call)) {
+            return undefined;
+        }
+        const at = (call.arguments ?? []).findIndex((argument) => argument === value);
+        const resolved = at < 0 ? undefined : must(queries.resolvedSignature(call));
+        const generic = resolved === undefined ? undefined : must(queries.genericOf(resolved));
+        return generic === undefined ? undefined : must(queries.typeAtPosition(generic, at));
+    };
     const pairs = new Map();
     const reach = (owner, source, target, name, site) => {
         const key = `${String(source.id)}:${String(target.id)}`;
@@ -197,12 +211,11 @@ export function interfaceSatisfaction(input) {
     const positions = queries.contextualTypes(carrying.map((one) => one.flow.value));
     carrying.forEach(({ flow, sources }, index) => {
         const position = must(positions[index]);
-        if (position === undefined) {
-            return;
-        }
-        for (const reached of interfacesOf(position)) {
-            for (const source of sources) {
-                reach(source.owner, source.type, reached.type, reached.name, flow.value);
+        for (const type of [position, genericPosition(flow.value)]) {
+            for (const reached of type === undefined ? [] : interfacesOf(type)) {
+                for (const source of sources) {
+                    reach(source.owner, source.type, reached.type, reached.name, flow.value);
+                }
             }
         }
     });
@@ -218,7 +231,10 @@ export function interfaceSatisfaction(input) {
         }
         let names = required.get(pair.target.id);
         if (names === undefined) {
-            names = new Set(must(queries.propertiesOf(pair.target)).map((property) => property.escapedName));
+            names = new Map(must(queries.propertiesOf(pair.target)).map((property) => [
+                property.escapedName,
+                chains.declarationsOf(property),
+            ]));
             required.set(pair.target.id, names);
         }
         let answering = members.get(pair.owner.id);
@@ -226,18 +242,23 @@ export function interfaceSatisfaction(input) {
             const instance = instanceOf.get(pair.owner.id) ?? pair.source;
             answering = new Map(must(queries.propertiesOf(instance)).map((property) => [
                 property.escapedName,
-                chains.declarationsOf(property),
+                {
+                    ids: chains.declarationsOf(property),
+                    empty: emptyImplementation(project, property),
+                },
             ]));
             members.set(pair.owner.id, answering);
         }
         const detail = `satisfies ${pair.name}`;
-        for (const name of names) {
-            for (const id of answering.get(name) ?? []) {
+        for (const [name, methods] of names) {
+            const member = answering.get(name);
+            for (const id of member?.ids ?? []) {
                 for (const site of pair.sites) {
                     found.push({
                         id,
                         detail,
                         site: renderPosition(site.getSourceFile(), targetRoot, site.getStart()),
+                        implementing: { methods, empty: member?.empty ?? false },
                     });
                 }
             }
@@ -245,3 +266,44 @@ export function interfaceSatisfaction(input) {
     }
     return found;
 }
+/**
+ * Each project's records with every record dropped whose member implements only interface
+ * methods nothing calls, unless every implementation of such a method is empty, and a
+ * reference from each such method to the member, which then falls with the method.
+ * `references` is every reference of the run, a consumer's included.
+ */
+export function settledSatisfaction(projects, references) {
+    const methods = new Set(projects.flatMap((one) => one.held.symbols.filter((symbol) => symbol.kind === "interface-method").map((one) => one.id)));
+    const called = new Set(references.map((reference) => reference.to));
+    const bodies = new Map();
+    for (const record of projects.flatMap((one) => one.evidence)) {
+        for (const method of record.implementing?.methods ?? []) {
+            bodies.set(method, (bodies.get(method) ?? true) && record.implementing?.empty === true);
+        }
+    }
+    const uncalled = (method) => methods.has(method) && !called.has(method) && bodies.get(method) !== true;
+    return projects.map(({ evidence }) => {
+        const kept = [];
+        const added = [];
+        for (const record of evidence) {
+            const implemented = record.implementing?.methods ?? [];
+            if (record.class !== "interface-satisfaction" ||
+                implemented.length === 0 ||
+                !implemented.every(uncalled)) {
+                kept.push(record);
+                continue;
+            }
+            for (const method of implemented) {
+                added.push({
+                    from: method,
+                    to: record.id,
+                    position: record.site,
+                    use: "read",
+                    resolution: "override",
+                    test: false,
+                });
+            }
+        }
+        return { evidence: kept, references: added };
+    });
+}