@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.21

package/dist/src/references.js

@@ -1,461 +1,26 @@
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isMetaProperty, isModuleBlock, isModuleDeclaration, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
+/**
+ * Every use one side's files make of the target's declarations: one walk and one batched
+ * resolution per file, never a reference query per symbol, whose answers would depend on the
+ * order the symbols are asked in. A reference carries its use, its position, the declaration
+ * enclosing it and whether a test file made it; it carries no mode: which references a run
+ * counts is the sweep's reading of this set.
+ */
+import { SyntaxKind } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
+import { augmentationReferences, mergedGlobalInterfaces } from "./augmentations.js";
 import { contextualUses } from "./contextual-uses.js";
-import { destructuring, propertyReadsOf } from "./destructuring.js";
-import { specifierCandidates } from "./configuration-files.js";
-import { namespaceUses } from "./namespace-objects.js";
-import { globExpression } from "./glob.js";
-import { declarationsByName, isParameterProperty, nodeKey, } from "./inventory.js";
-import { ambientGlobalInterfaces, augmentationReferences } from "./augmentations.js";
-import { elementAccessReferences } from "./element-access.js";
-import { indexedAccessReferences } from "./indexed-access.js";
-import { keyofComparisonReferences } from "./keyof-comparisons.js";
-import { unimplementedCalleeReads } from "./unimplemented-callees.js";
-import { moduleDeclarationReferences } from "./module-declarations.js";
-import { overrideReferences } from "./overrides.js";
-import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./paths.js";
-import { byPosition, isComponentFile, renderPosition } from "./position.js";
+import { destructuring } from "./destructuring.js";
+import { bindingsOf } from "./import-bindings.js";
+import { sitesOf } from "./index/sites.js";
+import { nodeKey } from "./inventory.js";
+import { relativePath } from "./paths.js";
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED } from "./query.js";
-import { typeParameterReads } from "./type-parameter-reads.js";
+import { heldBy, READ_RULES } from "./references/read-rules.js";
+import { Sink } from "./references/sink.js";
+import { emitFile, prepared } from "./references/sources.js";
+import { sourceFilesOf } from "./source-files.js";
+import { bytewise } from "./text/compare.js";
 import { typeQueryAliases } from "./type-query-alias.js";
-import { computedKeyNames, iterationReferences, keyNameOf, keyedUses, } from "./symbol-keys.js";
-import { handedOn, valuesOf } from "./value-flow.js";
-/**
- * The operators whose left side one assignment stores into. A compound assignment is
- * among them: where its value is discarded it reads its target only to write the result
- * back, so nothing else receives what it read.
- */
-const ASSIGNMENTS = new Set([
-    SyntaxKind.EqualsToken,
-    SyntaxKind.PlusEqualsToken,
-    SyntaxKind.MinusEqualsToken,
-    SyntaxKind.AsteriskEqualsToken,
-    SyntaxKind.AsteriskAsteriskEqualsToken,
-    SyntaxKind.SlashEqualsToken,
-    SyntaxKind.PercentEqualsToken,
-    SyntaxKind.LessThanLessThanEqualsToken,
-    SyntaxKind.GreaterThanGreaterThanEqualsToken,
-    SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
-    SyntaxKind.AmpersandEqualsToken,
-    SyntaxKind.BarEqualsToken,
-    SyntaxKind.BarBarEqualsToken,
-    SyntaxKind.AmpersandAmpersandEqualsToken,
-    SyntaxKind.QuestionQuestionEqualsToken,
-    SyntaxKind.CaretEqualsToken,
-]);
-/**
- * The assignments that read their target to decide whether to store at all, so the read
- * carries information out whatever becomes of the result.
- */
-const LOGICAL_ASSIGNMENTS = new Set([
-    SyntaxKind.BarBarEqualsToken,
-    SyntaxKind.AmpersandAmpersandEqualsToken,
-    SyntaxKind.QuestionQuestionEqualsToken,
-]);
-/**
- * Whether the value of one store expression is discarded: it is a statement of its own, a
- * clause of a `for` loop, the operand of `void`, or the left operand of a comma.
- */
-function valueDiscarded(node) {
-    let child = node;
-    let parent = node.parent;
-    while (isParenthesizedExpression(parent)) {
-        child = parent;
-        parent = parent.parent;
-    }
-    if (isExpressionStatement(parent) || isVoidExpression(parent)) {
-        return true;
-    }
-    if (isForStatement(parent)) {
-        return parent.initializer === child || parent.incrementor === child;
-    }
-    return (isBinaryExpression(parent) &&
-        parent.operatorToken.kind === SyntaxKind.CommaToken &&
-        parent.left === child);
-}
-/** Whether one node is an identifier or a private name, the two forms a name takes. */
-function isName(node) {
-    return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier;
-}
-/** The expression one node is, through however many parentheses are written around it. */
-function unparenthesized(node) {
-    let held = node;
-    while (isParenthesizedExpression(held)) {
-        held = held.expression;
-    }
-    return held;
-}
-/**
- * Records the name one store writes into.
- *
- * A property access writes the member it names. An element access writes the collection
- * it stores into, since a collection a module only stores into holds nothing anything
- * reads, and joins `accesses` for the member a unique-symbol key selects. A destructuring
- * target writes each name it binds, through its spreads and nested patterns.
- */
-function markWrite(target, writes, accesses) {
-    const held = unparenthesized(target);
-    if (isName(held)) {
-        writes.add(held.pos);
-        return;
-    }
-    if (isPropertyAccessExpression(held)) {
-        if (isName(held.name)) {
-            writes.add(held.name.pos);
-        }
-        return;
-    }
-    if (isElementAccessExpression(held)) {
-        accesses.add(held);
-        // A store through a member's value lands in storage every holder of the value
-        // reads, so it reads the member; a variable only ever stored into stays written.
-        if (!isPropertyAccessExpression(unparenthesized(held.expression))) {
-            markWrite(held.expression, writes, accesses);
-        }
-        return;
-    }
-    if (isArrayLiteralExpression(held)) {
-        for (const element of held.elements) {
-            markWrite(element, writes, accesses);
-        }
-        return;
-    }
-    if (isObjectLiteralExpression(held)) {
-        for (const property of held.properties) {
-            if (isPropertyAssignment(property)) {
-                markWrite(property.initializer, writes, accesses);
-                continue;
-            }
-            if (isShorthandPropertyAssignment(property)) {
-                markWrite(property.name, writes, accesses);
-                continue;
-            }
-            if (isSpreadAssignment(property)) {
-                markWrite(property.expression, writes, accesses);
-            }
-        }
-        return;
-    }
-    if (isSpreadElement(held)) {
-        markWrite(held.expression, writes, accesses);
-    }
-}
-/**
- * Records every store one node performs: an assignment, a compound assignment, an
- * increment or a decrement, a `delete`, and an iteration that assigns to a name declared
- * elsewhere. An iteration that declares its own name stores into nothing the inventory
- * holds. A store that reads its target as well records it in `reads`: a logical
- * assignment, and a compound assignment, an increment or a decrement whose value is used.
- */
-function markStores(node, writes, reads, accesses) {
-    if (isBinaryExpression(node)) {
-        const operator = node.operatorToken.kind;
-        if (ASSIGNMENTS.has(operator)) {
-            markWrite(node.left, writes, accesses.written);
-            if (LOGICAL_ASSIGNMENTS.has(operator) ||
-                (operator !== SyntaxKind.EqualsToken && !valueDiscarded(node))) {
-                markWrite(node.left, reads, accesses.read);
-            }
-        }
-        return;
-    }
-    if (isPrefixUnaryExpression(node) || isPostfixUnaryExpression(node)) {
-        if (node.operator === SyntaxKind.PlusPlusToken ||
-            node.operator === SyntaxKind.MinusMinusToken) {
-            markWrite(node.operand, writes, accesses.written);
-            if (!valueDiscarded(node)) {
-                markWrite(node.operand, reads, accesses.read);
-            }
-        }
-        return;
-    }
-    if (isDeleteExpression(node)) {
-        markWrite(node.expression, writes, accesses.written);
-        return;
-    }
-    if (isForInStatement(node) || isForOfStatement(node)) {
-        if (node.initializer.kind !== SyntaxKind.VariableDeclarationList) {
-            markWrite(node.initializer, writes, accesses.written);
-        }
-    }
-}
-/** Whether one node is `import.meta.url`. */
-function isImportMetaURL(node) {
-    const at = unparenthesized(node);
-    return (isPropertyAccessExpression(at) &&
-        isMetaProperty(at.expression) &&
-        at.expression.keywordToken === SyntaxKind.ImportKeyword &&
-        at.name.text === "url");
-}
-/** The module URL one node builds, where it builds one. */
-function moduleURLOf(node) {
-    const relative = (argument) => {
-        const at = argument === undefined ? undefined : unparenthesized(argument);
-        return at !== undefined &&
-            (isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at)) &&
-            /^\.\.?\//u.test(at.text)
-            ? at.text
-            : undefined;
-    };
-    if (isNewExpression(node) && isIdentifier(node.expression) && node.expression.text === "URL") {
-        const [reference, base] = node.arguments ?? [];
-        const specifier = relative(reference);
-        return specifier !== undefined && base !== undefined && isImportMetaURL(base)
-            ? { specifier, constructor: node.expression, at: node }
-            : undefined;
-    }
-    if (isCallExpression(node)) {
-        const callee = unparenthesized(node.expression);
-        const specifier = relative(node.arguments[0]);
-        if (specifier !== undefined &&
-            isPropertyAccessExpression(callee) &&
-            isMetaProperty(callee.expression) &&
-            callee.expression.keywordToken === SyntaxKind.ImportKeyword &&
-            callee.name.text === "resolve") {
-            return { specifier, constructor: undefined, at: node };
-        }
-    }
-    return undefined;
-}
-/** Whether one node is a string literal or a template literal with no substitution. */
-function isLiteralText(node) {
-    return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
-}
-/**
- * The module specifier of the module one node evaluates, if it evaluates one: an import
- * declaration, an import-equals declaration of an external module, an export
- * declaration that names a module, and an `import()` call whose argument is literal
- * text. A type-only form evaluates nothing. An `import()` of a computed argument names
- * no module this pass can know.
- */
-function evaluatedBy(node) {
-    if (isImportDeclaration(node)) {
-        return node.importClause?.phaseModifier === SyntaxKind.TypeKeyword
-            ? undefined
-            : node.moduleSpecifier;
-    }
-    if (isExportDeclaration(node)) {
-        return node.isTypeOnly ? undefined : node.moduleSpecifier;
-    }
-    if (isImportEqualsDeclaration(node)) {
-        const reference = node.moduleReference;
-        return !node.isTypeOnly && isExternalModuleReference(reference)
-            ? reference.expression
-            : undefined;
-    }
-    if (isCallExpression(node) && node.expression.kind === SyntaxKind.ImportKeyword) {
-        const [argument] = node.arguments;
-        return isLiteralText(argument) ? argument : undefined;
-    }
-    return undefined;
-}
-/**
- * The own file a module specifier with a query evaluates ({@link queriedModulePath}): the
- * checker resolves the whole specifier to whatever module declaration matches it.
- */
-function queriedFile(file, specifier, fileIdByName) {
-    if (!isStringLiteral(specifier) && !isNoSubstitutionTemplateLiteral(specifier)) {
-        return undefined;
-    }
-    const path = queriedModulePath(specifier.text);
-    return path === undefined
-        ? undefined
-        : fileIdByName.get(resolvePath(dirnamePath(file.fileName), path));
-}
-/**
- * The re-exports one node writes, if it is an export declaration. A specifier and a
- * namespace export are declarations whose names are where they are written, so no use is
- * read from them; each references what it carries forward instead. A bare star declares
- * nothing, so the declaration enclosing it, at the top level the file, references the
- * module it names.
- */
-function linksOf(file, node, declarations, enclosing) {
-    if (!isExportDeclaration(node)) {
-        return [];
-    }
-    const clause = node.exportClause;
-    const specifier = node.moduleSpecifier;
-    if (clause === undefined) {
-        return specifier === undefined
-            ? []
-            : [{ node: specifier, at: specifier, from: enclosing, alias: false }];
-    }
-    if (isNamespaceExport(clause)) {
-        const from = declarations.get(nodeKey(file, clause));
-        return from === undefined
-            ? []
-            : [{ node: clause.name, at: specifier ?? clause.name, from, alias: true }];
-    }
-    const found = [];
-    for (const element of clause.elements) {
-        const from = declarations.get(nodeKey(file, element));
-        if (from !== undefined) {
-            found.push({
-                node: element.name,
-                at: element.propertyName ?? element.name,
-                from,
-                alias: true,
-            });
-        }
-    }
-    return found;
-}
-/**
- * Whether one object literal is a destructuring target, written on the left of an
- * assignment or as a `for` loop's initializer, through the literals and spreads it nests in.
- */
-function isAssignmentPattern(node) {
-    let child = node;
-    let parent = node.parent;
-    while (isParenthesizedExpression(parent) ||
-        isArrayLiteralExpression(parent) ||
-        isObjectLiteralExpression(parent) ||
-        isSpreadElement(parent) ||
-        isSpreadAssignment(parent) ||
-        (isPropertyAssignment(parent) && parent.initializer === child)) {
-        child = parent;
-        parent = parent.parent;
-    }
-    if (isBinaryExpression(parent)) {
-        return parent.operatorToken.kind === SyntaxKind.EqualsToken && parent.left === child;
-    }
-    return (isForInStatement(parent) || isForOfStatement(parent)) && parent.initializer === child;
-}
-/**
- * Every name node one file holds that is a use rather than a declaration, in source
- * order, each with its enclosing declaration and its use, and every re-export the file
- * writes. One walk answers all of it, because a second would have to agree with this one
- * about which nodes are names. A declaration's own declared name is left out, which is
- * what makes a declaration referenced only from its own site an unreferenced one, and so
- * is every node of `unread`, a subtree that is no use.
- */
-function sitesOf(file, declarations, fileId, unread) {
-    const found = [];
-    const reads = [];
-    const links = [];
-    const evaluations = [];
-    const wholes = [];
-    const urls = [];
-    const decorated = [];
-    const parameterWrites = [];
-    const namespaces = namespaceUses(file);
-    const literals = [];
-    const flows = [];
-    const writes = new Set();
-    const alsoRead = new Set();
-    const accesses = { written: new Set(), read: new Set() };
-    const keyed = [];
-    const declared = new Set();
-    const shorthands = new Map();
-    let enclosing = fileId;
-    const markNames = (node) => {
-        if (isShorthandPropertyAssignment(node)) {
-            shorthands.set(node.name.pos, node);
-            return;
-        }
-        // A property access carries the member it names where a declaration carries its
-        // declared name, and it is the one form of the grammar that does.
-        if (isPropertyAccessExpression(node)) {
-            return;
-        }
-        const named = node;
-        for (const name of [named.name, named.propertyName]) {
-            if (name !== undefined && isName(name)) {
-                declared.add(name.pos);
-            }
-        }
-    };
-    const visit = (node) => {
-        if (unread.has(node)) {
-            return;
-        }
-        const namespace = namespaces.get(node);
-        if (namespace?.kind === "whole") {
-            wholes.push({ specifier: namespace.specifier, at: node, from: enclosing });
-        }
-        else if (namespace?.kind === "indexed") {
-            found.push({ node: namespace.literal, shorthand: undefined, from: enclosing, use: "read" });
-        }
-        if (isName(node)) {
-            if (!declared.has(node.pos)) {
-                const site = { node, shorthand: shorthands.get(node.pos), from: enclosing };
-                if (writes.has(node.pos)) {
-                    found.push({ ...site, use: "write" });
-                }
-                if (!writes.has(node.pos) || alsoRead.has(node.pos)) {
-                    found.push({ ...site, use: "read" });
-                }
-            }
-            return;
-        }
-        markNames(node);
-        markStores(node, writes, alsoRead, accesses);
-        const key = isElementAccessExpression(node) ? keyNameOf(node.argumentExpression) : undefined;
-        if (key !== undefined && isElementAccessExpression(node)) {
-            const written = accesses.written.has(node);
-            keyed.push({
-                access: node,
-                key,
-                from: enclosing,
-                use: written ? (accesses.read.has(node) ? "both" : "write") : "read",
-            });
-        }
-        if (isObjectLiteralExpression(node) && !isAssignmentPattern(node)) {
-            literals.push({ literal: node, from: enclosing });
-        }
-        // An assertion needs only comparability, so no member of its operand is read by it.
-        for (const written of isAsExpression(node) ? [] : handedOn(node)) {
-            flows.push(...valuesOf(written).map((value) => ({ value, from: enclosing })));
-        }
-        for (const read of propertyReadsOf(node)) {
-            reads.push({ ...read, from: enclosing });
-        }
-        links.push(...linksOf(file, node, declarations, enclosing));
-        const evaluated = evaluatedBy(node);
-        if (evaluated !== undefined) {
-            evaluations.push({ node: evaluated, from: enclosing });
-        }
-        const url = moduleURLOf(node);
-        if (url !== undefined) {
-            urls.push(url);
-        }
-        const held = declarations.get(nodeKey(file, node));
-        const outer = enclosing;
-        // A parameter property's annotation, initializer and decorators stay with the
-        // parameter when the member goes, so they are written inside the constructor's class.
-        if (held !== undefined && isParameterProperty(node)) {
-            parameterWrites.push({
-                name: node.name,
-                from: outer,
-                member: held,
-            });
-        }
-        else if (held !== undefined) {
-            enclosing = held;
-            for (const modifier of node.modifiers ?? []) {
-                if (isDecorator(modifier)) {
-                    decorated.push({ decorator: modifier, declaration: held });
-                }
-            }
-        }
-        node.forEachChild(visit);
-        enclosing = outer;
-    };
-    file.forEachChild(visit);
-    return {
-        uses: found,
-        literals,
-        flows,
-        reads,
-        links,
-        evaluations,
-        wholes,
-        urls,
-        decorated,
-        parameterWrites,
-        keyed,
-    };
-}
 /** The declaration kinds of a property an object literal declares. */
 const LITERAL_PROPERTY_KINDS = new Set([
     SyntaxKind.PropertyAssignment,
@@ -464,196 +29,20 @@ const LITERAL_PROPERTY_KINDS = new Set([
     SyntaxKind.GetAccessor,
     SyntaxKind.SetAccessor,
 ]);
-/** The rule a file the analysis classified as test-support code is counted under. */
-const TEST_SUPPORT_RULE = "test-support";
-/**
- * The name one test-file rule takes. A rule's name is a word list the report's own
- * vocabulary spells, which cannot carry a pattern, so a rule is named by the place of
- * its pattern in the configured list.
- */
-function patternRule(index) {
-    return `test-file-pattern-${String(index + 1)}`;
-}
-/**
- * The rules over the test files of several projects at once, ordered by rule: a file two
- * projects hold is one file, so each rule counts the distinct paths it matches.
- */
-export function testFileRulesOf(testFiles, paths, supportFiles = []) {
-    const distinct = [...new Set(paths)];
-    const support = new Set(supportFiles).size;
-    return [
-        ...testFiles.map((pattern, index) => {
-            const expression = globExpression(pattern);
-            return {
-                rule: patternRule(index),
-                matched: distinct.filter((path) => expression.test(path)).length,
-            };
-        }),
-        ...(support === 0 ? [] : [{ rule: TEST_SUPPORT_RULE, matched: support }]),
-    ].sort((a, b) => compare(a.rule, b.rule));
-}
-const importedCache = new WeakMap();
-/**
- * Each local name one file's imports bind, mapped to the names it imports: the
- * exported name of a named import, `default` for a default import, and `undefined` for
- * a namespace import or an import assignment, which binds a whole module.
- */
-function importedNames(file) {
-    const known = importedCache.get(file);
-    if (known !== undefined) {
-        return known;
-    }
-    const names = new Map();
-    const bind = (local, imported) => {
-        names.set(local, [...(names.get(local) ?? []), imported]);
-    };
-    for (const statement of file.statements) {
-        if (isImportEqualsDeclaration(statement)) {
-            bind(statement.name.text, undefined);
-            continue;
-        }
-        const clause = isImportDeclaration(statement) ? statement.importClause : undefined;
-        if (clause === undefined) {
-            continue;
-        }
-        if (clause.name !== undefined) {
-            bind(clause.name.text, "default");
-        }
-        const bindings = clause.namedBindings;
-        if (bindings === undefined) {
-            continue;
-        }
-        if (bindings.kind === SyntaxKind.NamespaceImport) {
-            bind(bindings.name.text, undefined);
-        }
-        else {
-            for (const element of bindings.elements) {
-                bind(element.name.text, element.propertyName?.text ?? element.name.text);
-            }
-        }
-    }
-    importedCache.set(file, names);
-    return names;
-}
-/** The name node of every import binding one file's top level declares. */
-function importBindings(file) {
-    const found = [];
-    for (const statement of file.statements) {
-        if (isImportEqualsDeclaration(statement)) {
-            found.push({ node: statement.name });
-            continue;
-        }
-        const clause = isImportDeclaration(statement) ? statement.importClause : undefined;
-        if (clause === undefined) {
-            continue;
-        }
-        if (clause.name !== undefined) {
-            found.push({ node: clause.name });
-        }
-        const bindings = clause.namedBindings;
-        if (bindings === undefined) {
-            continue;
-        }
-        if (bindings.kind === SyntaxKind.NamespaceImport) {
-            found.push({ node: bindings.name });
-        }
-        else {
-            found.push(...bindings.elements.map((element) => ({ node: element.name })));
-        }
-    }
-    return found;
-}
-/** The value one assignment stores through the name it writes, where it is a plain assignment. */
-function storedValue(name) {
-    let target = name;
-    if (isPropertyAccessExpression(name.parent) && name.parent.name === name) {
-        target = name.parent;
-    }
-    while (isParenthesizedExpression(target.parent)) {
-        target = target.parent;
-    }
-    const parent = target.parent;
-    return isBinaryExpression(parent) &&
-        parent.operatorToken.kind === SyntaxKind.EqualsToken &&
-        parent.left === target
-        ? parent.right
-        : undefined;
-}
-/**
- * The import bindings of one file that only the values written into one declaration
- * use, for each write into it. A binding is named by an identifier that spells its
- * local name and is not the member a property access names.
- */
-function aloneIn(file, uses, writes, found) {
-    const bindings = new Set(importBindings(file).map((binding) => binding.node.getText()));
-    if (bindings.size === 0) {
-        return [];
-    }
-    const occurrences = new Map();
-    for (const site of uses) {
-        const text = site.node.getText();
-        const parent = site.node.parent;
-        if (!bindings.has(text) || (isPropertyAccessExpression(parent) && parent.name === site.node)) {
-            continue;
-        }
-        if (!occurrences.get(text)?.includes(site.node)) {
-            occurrences.set(text, [...(occurrences.get(text) ?? []), site.node]);
-        }
-    }
-    const inside = (node, value) => node.pos >= value.pos && node.end <= value.end;
-    const result = [];
-    for (const write of writes) {
-        const to = found[write.index]?.to;
-        const sameTarget = writes.filter((one) => found[one.index]?.to === to);
-        const names = [...occurrences]
-            .filter(([, nodes]) => nodes.some((node) => inside(node, write.value)) &&
-            nodes.every((node) => sameTarget.some((one) => inside(node, one.value))))
-            .map(([name]) => name)
-            .sort(compare);
-        if (names.length > 0) {
-            result.push({ index: write.index, names });
-        }
-    }
-    return result;
-}
-/** Two strings ordered bytewise, which is the order every set of a run is read in. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /**
- * Every reference one project's own files make to the project's own declarations, in
- * position order, and the files the test-file rules classified.
- *
- * `held` is the inventory of the same project, whose declaration map is what a resolved
- * symbol is looked up in; `targetRoot` is the absolute path every position is rendered
- * against, which is the root the inventory was read against. A pass over a consumer
- * walks the consumer's files instead and renders against its root, as
- * {@link ReferenceOptions.consumer} states.
- *
- * The order is by the referencing position, then by the declaration named, the
- * declaration referencing it and the use. That is a total order because one name
- * references one declaration once from one declaration, while a chain of aliases reaches
- * several declarations at one position and a bare star re-export's specifier both reads
- * and evaluates the module it names.
+ * Every reference one side's files make to the target's declarations. `held` is the
+ * target's inventory over the files the project holds, where a resolved symbol is looked up;
+ * positions render against `targetRoot`, or a consumer's root as
+ * {@link ReferenceOptions.consumer} states. The order is by position, then the declaration
+ * named, the referencing declaration and the use: an alias chain or a bare star re-export
+ * names several at one position, and one name references one declaration once.
  */
 export function references(project, held, targetRoot, options) {
     const cap = options.batchCap ?? DEFAULT_BATCH_CAP;
     const declarations = held.declarations;
-    const patterns = options.testFiles.map(globExpression);
-    const found = [];
-    const tests = [];
     const chains = aliasChains(project, held);
     const tables = propertyTables(project.queries);
-    const destructured = destructuring(project, cap, tables);
-    let batched = 0;
-    let fileBatches = 0;
-    let residueFallbacks = 0;
-    let shorthandLookups = 0;
     const consumer = options.consumer;
-    const root = consumer?.root ?? targetRoot;
     const files = consumer === undefined
         ? project.ownSourceFiles()
         : project
@@ -662,6 +51,8 @@ export function references(project, held, targetRoot, options) {
             relativePath(targetRoot, file.fileName) === undefined);
     const ownPaths = project.ownPaths();
     const fileIds = new Set(held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id));
+    const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
+    const sink = new Sink(consumer?.root ?? targetRoot, options.testFile, consumer, declaredAt);
     let moduleBodies;
     /**
      * The declarations one module holds directly: a file's top level, or the body of a
@@ -671,21 +62,17 @@ export function references(project, held, targetRoot, options) {
         if (moduleBodies === undefined) {
             const byModule = new Map();
             for (const symbol of held.symbols) {
-                if (!fileIds.has(symbol.parent) && !held.modules.has(symbol.parent)) {
-                    continue;
-                }
-                const siblings = byModule.get(symbol.parent);
-                if (siblings === undefined) {
-                    byModule.set(symbol.parent, [symbol]);
-                }
-                else {
-                    siblings.push(symbol);
+                if (fileIds.has(symbol.parent) || held.modules.has(symbol.parent)) {
+                    byModule.set(symbol.parent, [...(byModule.get(symbol.parent) ?? []), symbol]);
                 }
             }
             moduleBodies = byModule;
         }
         return moduleBodies.get(moduleId) ?? [];
     };
+    const exportedBy = (ids) => [...ids].flatMap((id) => declaredIn(id)
+        .filter((symbol) => symbol.exported)
+        .map((symbol) => ({ id: symbol.id, stepped: false, guessed: true })));
     const exportsCache = new Map();
     /**
      * Every declaration one module exports, each re-export walked along its chain. A module
@@ -693,9 +80,7 @@ export function references(project, held, targetRoot, options) {
      */
     const exportsRead = (module) => {
         if (module === UNANSWERED) {
-            return [...fileIds].flatMap((id) => declaredIn(id)
-                .filter((symbol) => symbol.exported)
-                .map((symbol) => ({ id: symbol.id, stepped: false, guessed: true })));
+            return exportedBy(fileIds);
         }
         const known = exportsCache.get(module.id);
         if (known !== undefined) {
@@ -703,41 +88,26 @@ export function references(project, held, targetRoot, options) {
         }
         const table = project.queries.exportsOfModule(module);
         const read = table === UNANSWERED
-            ? chains.declarationsOf(module).flatMap((id) => declaredIn(id)
-                .filter((symbol) => symbol.exported)
-                .map((symbol) => ({ id: symbol.id, stepped: false, guessed: true })))
+            ? exportedBy(chains.declarationsOf(module))
             : table.flatMap((exported) => chains.chainOf(exported));
         exportsCache.set(module.id, read);
         return read;
     };
-    /** The identifier of the declaration one node of this program is, where it is one. */
-    const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
-    /**
-     * The declarations one re-export carries forward: for an alias, the first link along
-     * its chain that the inventory declares, stepping over the links it does not, such as
-     * an import the re-export is written against; for a bare star, the module it names.
-     * Each later link is a declaration of its own that references the next, so one link
-     * per re-export is what lets a chain be followed one declaration at a time.
-     */
-    const carriedBy = (link, symbol) => link.alias
-        ? chains.nextDeclared(symbol)
-        : chains.declarationsOf(symbol).map((id) => ({ id, stepped: false, guessed: false }));
     /**
-     * Every declaration bearing the name one node spells, or the name an import of its
-     * file binds that name to, which is what a reference the checker could not resolve is
-     * counted as: it may be a use of any of them, and a declaration it may use is kept
-     * live. A name a namespace import binds may be a use of any file.
+     * Every declaration bearing the name one node spells, or the name an import of its file
+     * binds that name to, which is what a reference the checker could not resolve is counted
+     * as (program.33): it may be a use of any of them. A name a namespace import binds may be
+     * a use of any file.
      */
     const named = (node) => {
-        const byName = declarationsByName(held);
         const text = node.getText();
-        const imported = importedNames(node.getSourceFile()).get(text) ?? [];
+        const imported = bindingsOf(node.getSourceFile()).filter((binding) => binding.name.text === text);
         return [
             ...new Set([
-                ...(byName.get(text) ?? []),
-                ...imported.flatMap((name) => name === undefined ? [...fileIds] : (byName.get(name) ?? [])),
+                ...(held.byName.get(text) ?? []),
+                ...imported.flatMap((binding) => binding.imported === undefined ? [...fileIds] : (held.byName.get(binding.imported) ?? [])),
             ]),
-        ];
+        ].map((id) => ({ id, stepped: false, guessed: true }));
     };
     // A type-query alias's own type names its export without using it; a use of the
     // global is the use, so it names every link of the export's chain as well.
@@ -753,7 +123,7 @@ export function references(project, held, targetRoot, options) {
                 return;
             }
             aliased.set(id, symbol === UNANSWERED
-                ? (declarationsByName(held).get(alias.name) ?? []).map((one) => ({
+                ? (held.byName.get(alias.name) ?? []).map((one) => ({
                     id: one,
                     stepped: true,
                     guessed: true,
@@ -778,25 +148,25 @@ export function references(project, held, targetRoot, options) {
         }
         return all;
     };
-    /** The symbol one site resolves to, asking only the accessor the site's form names. */
-    const symbolFor = (site, answered) => {
-        if (site.shorthand !== undefined) {
-            shorthandLookups += 1;
-            return project.shorthandValueAt(project.handle(site.shorthand));
-        }
-        const batched = answered.get(site.node);
-        if (batched === UNANSWERED || typeof batched === "object") {
-            return batched;
-        }
-        residueFallbacks += 1;
-        return project.resolvedSymbolAt(project.handle(site.node));
-    };
-    const walked = files.map((file) => {
+    const rules = READ_RULES.map((rule) => rule.start());
+    const sites = files.map((file) => {
         const fileId = declaredAt(file) ?? "";
-        return { file, fileId, ...sitesOf(file, declarations, fileId, unread) };
+        return {
+            file,
+            fileId,
+            ...sitesOf(file, declarations, fileId, unread, (node, from) => {
+                for (const rule of rules) {
+                    rule.visit(node, { file, from });
+                }
+            }),
+        };
     });
-    const fileIdByName = new Map(walked.filter((one) => fileIds.has(one.fileId)).map((one) => [one.file.fileName, one.fileId]));
-    const contextual = contextualUses(project, held, chains, walked.flatMap((one) => one.literals), walked.flatMap((one) => one.flows), cap, tables);
+    const loadable = sites
+        .filter((one) => fileIds.has(one.fileId))
+        .map(({ file, fileId }) => ({ file, fileId }));
+    const directories = options.directories;
+    const destructured = destructuring(project, cap, tables);
+    const contextual = contextualUses(project, held, chains, sites.flatMap((one) => one.literals), sites.flatMap((one) => one.flows), cap, tables);
     const writtenBy = new Map();
     for (const write of contextual.writes) {
         const property = write.at.parent;
@@ -813,404 +183,77 @@ export function references(project, held, targetRoot, options) {
             return known;
         }
         const found = [];
-        if (writtenBy.size > 0) {
-            for (const handle of symbol.declarations) {
-                if (!LITERAL_PROPERTY_KINDS.has(handle.kind) || !ownPaths.has(handle.path)) {
-                    continue;
-                }
-                const node = project.declarationAt(handle)?.node;
-                const ids = node === undefined ? undefined : writtenBy.get(nodeKey(node.getSourceFile(), node));
-                for (const id of ids ?? []) {
-                    if (!found.some((target) => target.id === id)) {
-                        found.push({ id, stepped: true, guessed: false });
-                    }
+        for (const handle of writtenBy.size === 0 ? [] : symbol.declarations) {
+            if (!LITERAL_PROPERTY_KINDS.has(handle.kind) || !ownPaths.has(handle.path)) {
+                continue;
+            }
+            const node = project.declarationAt(handle)?.node;
+            const ids = node === undefined ? undefined : writtenBy.get(nodeKey(node.getSourceFile(), node));
+            for (const id of ids ?? []) {
+                if (!found.some((target) => target.id === id)) {
+                    found.push({ id, stepped: true, guessed: false });
                 }
             }
         }
         forwardedCache.set(symbol.id, found);
         return found;
     };
-    /** One resolved symbol's declarations along its chain, and the members its literal properties write. */
-    const targetsOf = (symbol) => {
-        const through = forwarded(symbol);
-        return through.length === 0 ? chains.chainOf(symbol) : [...chains.chainOf(symbol), ...through];
+    let ownFiles;
+    const pass = {
+        project,
+        held,
+        chains,
+        tables,
+        cap,
+        sink,
+        consumer: consumer !== undefined,
+        directories,
+        fileIds,
+        fileIdByName: new Map(loadable.map((one) => [one.file.fileName, one.fileId])),
+        loadableById: new Map(loadable.map((one) => [one.fileId, one.file])),
+        destructured,
+        unseenLoads: [],
+        formedForNode: options.formedForNode === true,
+        possiblyLoaded: new Set(),
+        declaredIn,
+        exportsRead,
+        named,
+        targetsOf: (symbol) => {
+            const through = forwarded(symbol);
+            return through.length === 0
+                ? chains.chainOf(symbol)
+                : [...chains.chainOf(symbol), ...through];
+        },
+        throughAliases,
+        ownFiles: () => (ownFiles ??= sourceFilesOf(project, targetRoot)),
     };
-    const testFile = new Map();
-    for (const { file } of walked) {
-        const path = renderPosition(file, root, 0).path;
-        const test = patterns.some((pattern) => pattern.test(path)) ||
-            options.testFileNames?.has(file.fileName) === true;
-        testFile.set(file, test);
-        if (test) {
-            tests.push(path);
-        }
+    for (const site of contextual.writes) {
+        const file = site.at.getSourceFile();
+        sink.add(file, site.at, site.from, site.ids, "write", "contextual", site.at.parent);
     }
-    /** Each write reference's index in `found`, by its file, with the value it stores. */
-    const valued = new Map();
-    const holdsValue = (file, value) => {
-        if (value !== undefined) {
-            valued.set(file, [...(valued.get(file) ?? []), { index: found.length - 1, value }]);
-        }
-    };
-    for (const [use, sites] of [
-        ["write", contextual.writes],
-        ["read", contextual.reads],
-    ]) {
-        for (const site of sites) {
-            const file = site.at.getSourceFile();
-            const position = renderPosition(file, root, site.at.getStart());
-            for (const id of site.ids) {
-                found.push({
-                    from: site.from,
-                    to: id,
-                    position,
-                    use,
-                    resolution: "contextual",
-                    test: testFile.get(file) === true,
-                });
-                if (use === "write") {
-                    holdsValue(file, site.at.parent);
-                }
-            }
-        }
+    for (const site of contextual.reads) {
+        sink.add(site.at.getSourceFile(), site.at, site.from, site.ids, "read", "contextual");
     }
-    const keyNames = computedKeyNames(held.symbols);
-    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated, parameterWrites, keyed, } of walked) {
-        const test = testFile.get(file) === true;
-        // A component file's markup may use any binding its blocks declare at the top level.
-        const markup = isComponentFile(file);
-        const bindings = markup ? importBindings(file) : [];
-        // A decorator is written inside the declaration it is attached to and receives it,
-        // so the declaration is used where the decorator is written, whatever the
-        // decorator does with it.
-        for (const { decorator, declaration } of decorated) {
-            found.push({
-                from: declaration,
-                to: declaration,
-                position: renderPosition(file, root, decorator.getStart()),
-                use: "decorator",
-                resolution: "syntax",
-                test,
-            });
-        }
-        // The constructor stores its argument in the member a parameter property declares.
-        for (const { name, from, member } of parameterWrites) {
-            found.push({
-                from,
-                to: member,
-                position: renderPosition(file, root, name.getStart()),
-                use: "write",
-                resolution: "syntax",
-                test,
-            });
-        }
-        // One batch per capped run of the file's name nodes, the re-exports' nodes after
-        // the uses and the evaluated modules' specifiers last, each node once: a bare star
-        // re-export's specifier is a link and an evaluation both. A shorthand is left out
-        // of the batch: its name resolves to the property the literal declares, so the
-        // batch's answer for it would name something this project's inventory never holds.
-        const batching = [
-            ...new Set([
-                ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
-                ...links.map((link) => link.node),
-                ...evaluations.map((evaluation) => evaluation.node),
-                ...wholes.map((whole) => whole.specifier),
-                ...urls.flatMap((url) => url.constructor ?? []),
-                ...bindings.map((binding) => binding.node),
-            ]),
-        ];
-        const answered = new Map();
-        batched += batching.length;
-        for (let from = 0; from < batching.length; from += cap) {
-            const run = batching.slice(from, from + cap);
-            const answers = project.symbolsAt(run.map((node) => project.handle(node)), cap);
-            fileBatches += 1;
-            run.forEach((node, index) => {
-                const symbol = answers[index];
-                if (symbol !== undefined) {
-                    answered.set(node, symbol);
-                }
-            });
-        }
-        for (const link of links) {
-            const symbol = answered.get(link.node);
-            if (symbol === undefined) {
-                continue;
-            }
-            const position = renderPosition(file, root, link.at.getStart());
-            const carried = symbol === UNANSWERED
-                ? named(link.at).map((id) => ({ id, stepped: false, guessed: true }))
-                : carriedBy(link, symbol);
-            for (const target of carried) {
-                found.push({
-                    from: link.from,
-                    to: target.id,
-                    position,
-                    use: "read",
-                    resolution: target.guessed ? "by-name" : link.alias ? "alias" : "batch",
-                    test,
-                });
-            }
-        }
-        for (const evaluation of evaluations) {
-            const queried = queriedFile(file, evaluation.node, fileIdByName);
-            if (queried !== undefined) {
-                found.push({
-                    from: evaluation.from,
-                    to: queried,
-                    position: renderPosition(file, root, evaluation.node.getStart()),
-                    use: "evaluation",
-                    resolution: "syntax",
-                    test,
-                });
-            }
-            const module = answered.get(evaluation.node);
-            if (module === undefined) {
-                continue;
-            }
-            const position = renderPosition(file, root, evaluation.node.getStart());
-            // A module the checker could not resolve may be any file of the target.
-            const evaluated = module === UNANSWERED ? [...fileIds] : chains.declarationsOf(module);
-            for (const id of evaluated) {
-                if (fileIds.has(id)) {
-                    found.push({
-                        from: evaluation.from,
-                        to: id,
-                        position,
-                        use: "evaluation",
-                        resolution: module === UNANSWERED ? "by-name" : "batch",
-                        test,
-                    });
-                }
-            }
-        }
-        for (const url of urls) {
-            const constructor = url.constructor === undefined ? undefined : answered.get(url.constructor);
-            // An augmentation of the global `URL` merges into it, which keeps the
-            // library's declaration; a `URL` the target declares has no other.
-            if (typeof constructor === "object" &&
-                constructor.declarations.length > 0 &&
-                constructor.declarations.every((handle) => ownPaths.has(handle.path))) {
-                continue;
-            }
-            const loaded = specifierCandidates(dirnamePath(file.fileName), url.specifier)
-                .map((path) => fileIdByName.get(path))
-                .find((id) => id !== undefined);
-            if (loaded !== undefined) {
-                found.push({
-                    from: fileId,
-                    to: loaded,
-                    position: renderPosition(file, root, url.at.getStart()),
-                    use: "evaluation",
-                    resolution: "syntax",
-                    test,
-                });
-            }
-        }
-        for (const whole of wholes) {
-            const module = answered.get(whole.specifier);
-            if (module === undefined) {
-                continue;
-            }
-            const position = renderPosition(file, root, whole.at.getStart());
-            for (const target of exportsRead(module)) {
-                found.push({
-                    from: whole.from,
-                    to: target.id,
-                    position,
-                    use: "read",
-                    resolution: target.guessed ? "by-name" : "batch",
-                    test,
-                });
-            }
-        }
-        if (markup) {
-            for (const symbol of declaredIn(fileId)) {
-                found.push({
-                    from: fileId,
-                    to: symbol.id,
-                    position: symbol.position,
-                    use: "read",
-                    resolution: "syntax",
-                    test,
-                });
-            }
-            for (const binding of bindings) {
-                const symbol = answered.get(binding.node);
-                if (symbol === undefined) {
-                    continue;
-                }
-                const position = renderPosition(file, root, binding.node.getStart());
-                const chained = symbol === UNANSWERED
-                    ? named(binding.node).map((id) => ({ id, stepped: false, guessed: true }))
-                    : chains.chainOf(symbol);
-                // The markup may name any export of a module a binding's chain reaches, whether a
-                // namespace import binds it or a named or default import of a namespace re-export.
-                const targets = chained.flatMap((target) => [
-                    target,
-                    ...declaredIn(target.id)
-                        .filter((one) => one.exported)
-                        .map((one) => ({ ...target, id: one.id })),
-                ]);
-                for (const target of targets) {
-                    found.push({
-                        from: fileId,
-                        to: target.id,
-                        position,
-                        use: "read",
-                        resolution: target.guessed ? "by-name" : target.stepped ? "alias" : "batch",
-                        test,
-                    });
-                }
-            }
-        }
-        // A pattern names a property of the value it destructures, which no name node of
-        // the pattern resolves to: a shorthand's name is the local it binds.
-        destructured.resolve(reads).forEach((symbol, index) => {
-            const read = reads[index];
-            if (symbol === undefined || read === undefined) {
-                return;
-            }
-            const position = renderPosition(file, root, read.key.getStart());
-            const targets = symbol === UNANSWERED
-                ? (declarationsByName(held).get(read.name) ?? []).map((id) => ({
-                    id,
-                    stepped: false,
-                    guessed: true,
-                }))
-                : targetsOf(symbol);
-            for (const target of targets) {
-                found.push({
-                    from: read.from,
-                    to: target.id,
-                    position,
-                    use: "read",
-                    resolution: target.guessed ? "by-name" : "destructured",
-                    test,
-                });
-            }
-        });
-        const resolvedKeys = keyed.flatMap((access) => {
-            const symbol = isIdentifier(access.key) && keyNames.has(access.key.text)
-                ? answered.get(access.key)
-                : undefined;
-            return typeof symbol === "object" ? [{ access, symbol }] : [];
-        });
-        for (const { access, ids } of keyedUses(project, chains, resolvedKeys, tables, cap)) {
-            const position = renderPosition(file, root, access.access.argumentExpression.getStart());
-            for (const id of ids) {
-                for (const use of access.use === "both" ? ["read", "write"] : [access.use]) {
-                    found.push({ from: access.from, to: id, position, use, resolution: "keyed", test });
-                }
-            }
-        }
-        for (const site of uses) {
-            const direct = site.shorthand !== undefined
-                ? "shorthand"
-                : typeof answered.get(site.node) === "object"
-                    ? "batch"
-                    : "resolved-symbol";
-            const symbol = symbolFor(site, answered);
-            if (symbol === undefined) {
-                continue;
-            }
-            const position = renderPosition(file, root, site.node.getStart());
-            // A re-export something imports is used and so is the declaration behind it, so
-            // the use names every link of the chain its name stands at the head of.
-            const targets = throughAliases(symbol === UNANSWERED
-                ? named(site.node).map((id) => ({ id, stepped: false, guessed: true }))
-                : targetsOf(symbol));
-            for (const target of targets) {
-                found.push({
-                    from: site.from,
-                    to: target.id,
-                    position,
-                    use: site.use,
-                    resolution: target.guessed ? "by-name" : target.stepped ? "alias" : direct,
-                    test,
-                });
-                if (site.use === "write") {
-                    holdsValue(file, storedValue(site.node));
-                }
-            }
-        }
+    for (const one of sites) {
+        emitFile(prepared(one, pass, loadable), pass);
     }
-    /** The ambient global interfaces of the walked files that merge into a declaration outside the project's own files. */
-    const libraryMerged = (scripts) => {
-        const names = new Map();
-        const visit = (node) => {
-            if (isInterfaceDeclaration(node)) {
-                const id = declaredAt(node);
-                if (id !== undefined) {
-                    names.set(id, node.name);
-                }
+    const context = { project, held, chains };
+    for (const rule of rules) {
+        for (const read of rule.reads(context)) {
+            if (read.kind === "named") {
+                sink.add(read.file, read.at, read.from, [read.to], read.use, read.via, undefined, read.production);
             }
-            else if (isModuleDeclaration(node) || isModuleBlock(node)) {
-                node.forEachChild(visit);
+            else {
+                sink.hold(heldBy(read, context));
             }
-        };
-        for (const { file } of walked) {
-            file.forEachChild(visit);
         }
-        const global = new Set(ambientGlobalInterfaces(held, [...names.keys()], scripts));
-        const asked = [...names].filter(([id]) => global.has(id));
-        if (asked.length === 0) {
-            return new Set();
-        }
-        const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
-        return new Set(asked.flatMap(([id], at) => {
-            const symbol = answers[at];
-            return typeof symbol === "object" &&
-                symbol.declarations.some((handle) => !ownPaths.has(handle.path))
-                ? [id]
-                : [];
-        }));
-    };
-    const usesOf = new Map(walked.map((one) => [one.file, one.uses]));
-    for (const [file, writes] of valued) {
-        const uses = usesOf.get(file) ?? [];
-        for (const { index, names } of aloneIn(file, uses, writes, found)) {
-            const reference = found[index];
-            if (reference !== undefined) {
-                found[index] = { ...reference, alone: names };
-            }
-        }
-    }
-    let typedLookups = 0;
-    if (consumer === undefined) {
-        const before = options.requestCount?.() ?? 0;
-        found.push(...overrideReferences(project, held, chains, new Set(tests)));
-        found.push(...indexedAccessReferences(project, held, chains, root, new Set(tests)));
-        found.push(...elementAccessReferences(project, held, chains, root, new Set(tests)));
-        found.push(...keyofComparisonReferences(project, held, chains, root, new Set(tests)));
-        found.push(...iterationReferences(project, held, chains, root, new Set(tests)));
-        found.push(...typeParameterReads(project, held, chains, root, new Set(tests)));
-        found.push(...unimplementedCalleeReads(project, held, chains, root, new Set(tests)));
-        found.push(...moduleDeclarationReferences(project, held, root, new Set(tests)));
-        typedLookups = (options.requestCount?.() ?? 0) - before;
     }
-    const scripts = new Set(walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId));
-    found.push(...augmentationReferences(held, found, scripts, libraryMerged(scripts)));
-    found.sort((a, b) => byPosition(a.position, b.position) ||
-        compare(a.to, b.to) ||
-        compare(a.from, b.from) ||
-        compare(a.use, b.use));
+    const merges = mergedGlobalInterfaces(project, held, pass.ownFiles());
+    sink.extend(augmentationReferences(held, sink.made, merges.scripts, merges.interfaces));
+    const finished = sink.finish(new Map(sites.map((one) => [one.file, one.uses])));
     return {
-        references: consumer === undefined
-            ? found
-            : found.map((reference) => ({ ...reference, consumer: consumer.id })),
-        testFilePaths: tests.sort(compare),
-        cost: {
-            batched,
-            fileBatches,
-            residueFallbacks,
-            shorthandLookups,
-            aliasSteps: chains.steps,
-            patternBatches: destructured.cost.patternBatches,
-            patternLookups: destructured.cost.patternLookups,
-            contextualBatches: contextual.batches,
-            contextualLookups: contextual.lookups,
-            typedLookups,
-        },
+        ...finished,
+        unseenLoads: pass.unseenLoads,
+        possiblyLoaded: [...pass.possiblyLoaded].sort(bytewise),
     };
 }