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

package/dist/src/suppress.js

@@ -4,25 +4,20 @@
  * ignore entry or a baseline row. A bound record marks its declaration live before the
  * sweep, unless its code reports a part or a dependency row, and is in effect when it
  * withholds a finding its code would have produced there, dormant when the configuration
- * withholds every such finding anyway, and stale otherwise.
+ * or a hold withholds every such finding anyway, and stale otherwise.
  */
-import { ConfigError } from "./config.js";
+import { KIND_ROWS, REMEDIES, SYMBOL_SUBJECTS, } from "./contract/contract.generated.js";
+import { UsageError } from "./usage.js";
 import { positionKey } from "./position.js";
 import { isRef } from "./ref.js";
-/** The code a suppression that carries no reason is reported under. */
-export const SUPPRESSION_WITHOUT_REASON = "DS1701";
-/** The code an ignore entry or a baseline row that names no path is reported under. */
-export const UNSCOPED_ENTRY = "DS1702";
-/** The code a suppression that withholds nothing is reported under. */
-export const STALE_SUPPRESSION = "DS1703";
 /**
  * A directive, an entry or a document the grammar refuses before any finding exists: an
  * instruction the analysis cannot carry out. It is a malformed input, so the command line
  * answers it with the usage code.
  */
-export class SuppressionError extends ConfigError {
+export class SuppressionError extends UsageError {
     constructor(mechanism, at, text, want) {
-        super("malformed", at, `${mechanism} ${at}: ${text}: want ${want}`);
+        super(`${mechanism} ${at}: ${text}: want ${want}`);
         this.name = "SuppressionError";
     }
 }
@@ -71,73 +66,54 @@ export function isSymbolRef(value) {
 export function blankReason(reason) {
     return reason === undefined || /^[ \t\r\n]*$/u.test(reason);
 }
-/**
- * The subject kinds that are a dependency row, each with the code that reports one. An
- * ignore entry or a baseline row naming the row's reference and file withholds its finding
- * and marks nothing, and an inline directive never binds one.
- */
-const DEPENDENCY_SUBJECTS = new Map([
-    ["dependency", ["DS1601"]],
-    ["module-directive", ["DS1605"]],
-]);
-/**
- * The subject kinds that are a row of a document rather than a declaration of the program,
- * each with the codes that report one. Apart from a dependency row, nothing withholds a
- * finding about one.
- */
-const ROW_SUBJECTS = new Map([
-    ["file", ["DS1501", "DS1502"]],
-    ...DEPENDENCY_SUBJECTS,
-    ["root", ["DS1704"]],
-    ["configured-declaration", ["DS1706"]],
-    ["suppression", ["DS1701", "DS1702", "DS1703"]],
-    ["edge", ["DS1705"]],
-]);
+/** No hold. */
+const NO_HOLDS = { withholds: () => false, holdsRecord: () => false };
+/** The subject of the kind each live code names. */
+const SUBJECT_OF_CODE = new Map(KIND_ROWS.map((row) => [row.code, row.subject]));
+/** The subject a finding about one symbol kind is about. */
+function subjectOf(kind) {
+    return Object.hasOwn(SYMBOL_SUBJECTS, kind)
+        ? SYMBOL_SUBJECTS[kind]
+        : undefined;
+}
+/** Whether a subject is a row of a document rather than a declaration of the program. */
+function rowOf(subject) {
+    return subject === "file" || subject === "dependency" || subject === "record";
+}
 /** Whether a finding's subject is a row of a document rather than a declaration. */
 export function isRowSubject(kind) {
-    return ROW_SUBJECTS.has(kind);
+    return rowOf(subjectOf(kind));
 }
-/** Whether a code reports a row of a document. */
-export function isRowCode(code) {
-    return [...ROW_SUBJECTS.values()].some((codes) => codes.includes(code));
+/** The subject a code reports, which kinds.json's remedies table answers for. */
+export function subjectOfCode(code) {
+    return SUBJECT_OF_CODE.get(code);
 }
-/** Whether a finding's subject is a dependency row. */
-export function isDependencySubject(kind) {
-    return DEPENDENCY_SUBJECTS.has(kind);
-}
-/** Whether a code reports a dependency row, which only an ignore entry or a baseline row names. */
-export function isDependencyCode(code) {
-    return [...DEPENDENCY_SUBJECTS.values()].some((codes) => codes.includes(code));
+/**
+ * Whether a record of `mechanism` can name a finding about `subject`, as kinds.json's
+ * remedies table lists the suppressions of each subject. A subject the table does not
+ * know is a declaration's.
+ */
+export function names(subject, mechanism) {
+    return REMEDIES[subject ?? "declaration"].suppressions.includes(mechanism);
 }
-/** Whether a code reports a row of a document that no record of any mechanism can name. */
-export function isUnsuppressibleCode(code) {
-    return isRowCode(code) && !isDependencyCode(code);
+/** Whether a finding about a symbol of `kind` is one a record of `mechanism` can name. */
+export function namesKind(kind, mechanism) {
+    return names(subjectOf(kind), mechanism);
 }
 /**
- * The subject kinds that are a part of a declaration rather than a declaration: a part
+ * Whether a finding's subject is a part of the declaration its reference names: a part
  * has no reference of its own, so a finding about one names the declaration that holds
  * it, and the part is decided inside that declaration whatever uses it.
  */
-const PART_SUBJECTS = new Set([
-    "parameter",
-    "receiver",
-    "result",
-    "statement",
-    "case",
-    "store",
-]);
-/** Whether a finding's subject is a part of the declaration its reference names. */
 export function isPartSubject(kind) {
-    return PART_SUBJECTS.has(kind);
+    return subjectOf(kind) === "part";
 }
-/** The prefix of the codes of the part kinds, the intra-function range. */
-const PART_KIND_PREFIX = "DS18";
 /**
  * Whether a code is a part kind, whose record withholds its finding and marks nothing:
  * the record says the part is wanted, not that the declaration holding it is.
  */
 export function isPartKind(code) {
-    return code.startsWith(PART_KIND_PREFIX);
+    return SUBJECT_OF_CODE.get(code) === "part";
 }
 /** One finding's identity: its code and the position of the thing it names. */
 function claimKey(finding) {
@@ -155,14 +131,13 @@ export function pairs(record, finding) {
     if (record.code !== finding.code) {
         return false;
     }
-    if (DEPENDENCY_SUBJECTS.has(finding.symbol.kind)) {
-        return (record.mechanism !== "inline" &&
-            record.symbol === finding.symbol.ref &&
-            record.path === finding.position.path);
-    }
-    if (ROW_SUBJECTS.has(finding.symbol.kind)) {
+    const subject = subjectOf(finding.symbol.kind);
+    if (!names(subject, record.mechanism)) {
         return false;
     }
+    if (subject === "dependency") {
+        return record.symbol === finding.symbol.ref && record.path === finding.position.path;
+    }
     if (record.bound !== "" && record.bound === positionKey(finding.position)) {
         return true;
     }
@@ -174,10 +149,10 @@ export function pairs(record, finding) {
  * there: swept with no mark for a liveness kind, and as swept otherwise. The first record
  * in reading order claims a finding, so a second naming it is stale; a part-kind record
  * claims every finding of its code about a part of its declaration. A record is dormant
- * when the dials withhold every finding it claims, read from those findings alone, or when
- * it claims none and its code's severity is `allow`.
+ * when the dials or `holds` withhold every finding it claims, or when it claims none and
+ * its code is at `allow` or a hold keeps its declaration live.
  */
-export function ledgerOf(records, would, dials) {
+export function ledgerOf(records, would, dials, holds = NO_HOLDS) {
     const taken = new Set();
     const verdicts = [];
     for (const record of records) {
@@ -185,13 +160,17 @@ export function ledgerOf(records, would, dials) {
         const first = would.find(open);
         const claimed = first === undefined ? [] : isPartKind(record.code) ? would.filter(open) : [first];
         if (claimed.length === 0) {
-            verdicts.push(record.bound !== "" && dials.allows(record.code) ? "dormant" : "stale");
+            verdicts.push(record.bound !== "" && (dials.allows(record.code) || holds.holdsRecord(record))
+                ? "dormant"
+                : "stale");
             continue;
         }
         for (const finding of claimed) {
             taken.add(claimKey(finding));
         }
-        verdicts.push(claimed.every((finding) => dials.withholds(finding)) ? "dormant" : "in-effect");
+        verdicts.push(claimed.every((finding) => dials.withholds(finding) || holds.withholds(finding))
+            ? "dormant"
+            : "in-effect");
     }
     return {
         verdicts,

package/dist/src/symbol-keys.js

@@ -5,16 +5,12 @@
  * No name node resolves to such a member: the key's name resolves to the constant. An
  * iteration reads the member its well-known iteration symbol keys.
  */
-import { isComputedPropertyName, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPropertyAccessExpression, isSpreadElement, isStringLiteral, } from "@typescript/native/ast";
-import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
-import { isAnswered } from "./query.js";
+import { isComputedPropertyName, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isPropertyAccessExpression, isSpreadElement, isStringLiteral, } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** The identifier an element access's argument names its key by, where it is a name. */
 export function keyNameOf(argument) {
-    let at = argument;
-    while (isParenthesizedExpression(at)) {
-        at = at.expression;
-    }
+    const at = parenthesesRemoved(argument);
     if (isIdentifier(at)) {
         return at;
     }
@@ -129,87 +125,95 @@ function wellKnownName(name) {
         : undefined;
 }
 /**
- * The references the iterations of one project's own files make to the iteration members
- * of the values they iterate: a `for…of` statement and a spread element read
- * `[Symbol.iterator]`, and a `for await…of` statement reads `[Symbol.asyncIterator]` and,
- * which it falls back to, `[Symbol.iterator]`. Each is made by the declaration holding it.
+ * The reads the iterations of a side's files make of the iteration members of the values they
+ * iterate: a `for…of` statement and a spread element read `[Symbol.iterator]`, and a
+ * `for await…of` statement reads `[Symbol.asyncIterator]` and, which it falls back to,
+ * `[Symbol.iterator]`. Each is made by the declaration holding it. A value whose type or
+ * members the checker leaves unanswered holds the members those names could spell.
  */
-export function iterationReferences(project, held, chains, root, testFiles) {
-    const queries = project.queries;
-    const ownPaths = project.ownPaths();
-    const iterated = [];
-    for (const file of project.ownSourceFiles()) {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        if (fileId === undefined) {
-            continue;
-        }
-        const visit = (node, from) => {
-            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
-            if (isForOfStatement(node)) {
-                const protocols = node.awaitModifier === undefined ? ["iterator"] : ["asyncIterator", "iterator"];
-                iterated.push({ file, from: holder, operand: node.expression, protocols });
-            }
-            else if (isSpreadElement(node)) {
-                iterated.push({ file, from: holder, operand: node.expression, protocols: ["iterator"] });
-            }
-            node.forEachChild((child) => {
-                visit(child, holder);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId);
-        });
-    }
-    if (iterated.length === 0) {
-        return [];
-    }
-    const types = queries.typesAt(iterated.map((one) => one.operand));
-    const members = new Map();
-    const membersOf = (type) => {
-        const known = members.get(type.id);
-        if (known !== undefined) {
-            return known;
-        }
-        const keyed = [];
-        const properties = queries.propertiesOf(type);
-        for (const property of isAnswered(properties) ? properties : []) {
-            for (const handle of property.declarations) {
-                const node = ownPaths.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
-                const name = wellKnownName(node?.name);
-                if (name !== undefined) {
-                    keyed.push({ name, ids: chains.declarationsOf(property) });
-                    break;
+export const iteration = {
+    start() {
+        const iterated = [];
+        return {
+            visit(node, { file, from }) {
+                if (isForOfStatement(node)) {
+                    const protocols = node.awaitModifier === undefined ? ["iterator"] : ["asyncIterator", "iterator"];
+                    iterated.push({ file, from, operand: node.expression, protocols });
                 }
-            }
-        }
-        members.set(type.id, keyed);
-        return keyed;
-    };
-    const found = [];
-    iterated.forEach((one, index) => {
-        const type = types[index];
-        if (type === undefined || !isAnswered(type)) {
-            return;
-        }
-        const parts = type.isUnionType() || type.isIntersectionType() ? queries.constituents(type) : [type];
-        const position = renderPosition(one.file, root, one.operand.getStart());
-        for (const part of isAnswered(parts) ? parts : []) {
-            for (const member of membersOf(part)) {
-                if (!one.protocols.includes(member.name)) {
-                    continue;
+                else if (isSpreadElement(node)) {
+                    iterated.push({ file, from, operand: node.expression, protocols: ["iterator"] });
                 }
-                for (const to of member.ids) {
-                    found.push({
-                        from: one.from,
-                        to,
-                        position,
-                        use: "read",
-                        resolution: "keyed",
-                        test: testFiles.has(position.path),
-                    });
+            },
+            reads({ project, chains }) {
+                const found = [];
+                if (iterated.length === 0) {
+                    return found;
                 }
-            }
-        }
-    });
-    return found;
-}
+                const queries = project.queries;
+                const ownPaths = project.ownPaths();
+                const types = queries.typesAt(iterated.map((one) => one.operand));
+                const members = new Map();
+                const membersOf = (type) => {
+                    const known = members.get(type.id);
+                    if (known !== undefined) {
+                        return known;
+                    }
+                    const properties = queries.propertiesOf(type);
+                    const keyed = [];
+                    for (const property of isAnswered(properties) ? properties : []) {
+                        for (const handle of property.declarations) {
+                            const node = ownPaths.has(handle.path)
+                                ? project.declarationAt(handle)?.node
+                                : undefined;
+                            const name = wellKnownName(node?.name);
+                            if (name !== undefined) {
+                                keyed.push({ name, ids: chains.declarationsOf(property) });
+                                break;
+                            }
+                        }
+                    }
+                    const result = isAnswered(properties) ? keyed : UNANSWERED;
+                    members.set(type.id, result);
+                    return result;
+                };
+                // A member a well-known symbol keys is named by the symbol's computed name.
+                const spelled = (protocols) => protocols.map((protocol) => `Symbol.${protocol}`);
+                iterated.forEach((one, index) => {
+                    const type = types[index];
+                    if (type === UNANSWERED) {
+                        found.push({ kind: "held", from: one.from, names: spelled(one.protocols) });
+                        return;
+                    }
+                    if (type === undefined) {
+                        return;
+                    }
+                    const parts = type.isUnionType() || type.isIntersectionType() ? queries.constituents(type) : [type];
+                    for (const part of isAnswered(parts) ? parts : [type]) {
+                        const keyed = membersOf(part);
+                        if (keyed === UNANSWERED) {
+                            found.push({ kind: "held", from: one.from, names: spelled(one.protocols) });
+                            continue;
+                        }
+                        for (const member of keyed) {
+                            if (!one.protocols.includes(member.name)) {
+                                continue;
+                            }
+                            for (const to of member.ids) {
+                                found.push({
+                                    kind: "named",
+                                    from: one.from,
+                                    to,
+                                    file: one.file,
+                                    at: one.operand,
+                                    use: "read",
+                                    via: "keyed",
+                                });
+                            }
+                        }
+                    }
+                });
+                return found;
+            },
+        };
+    },
+};

package/dist/src/template-field.js

@@ -12,10 +12,12 @@
  * type, because nothing ties the name to a type.
  */
 import { readComponent } from "./component-files.js";
-import { ConfigError } from "./config.js";
 import { memberNames } from "./member-names.js";
 import { extensionOf, isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.js";
 import { isComponentFile } from "./position.js";
+import { bytewise } from "./text/compare.js";
+import { filesBelow } from "./fs/tree.js";
+import { UsageError } from "./usage.js";
 /** The kinds of declaration an action can name. */
 const READ_BY_A_TEMPLATE = new Set([
     "method",
@@ -30,13 +32,6 @@ const READ_BY_A_TEMPLATE = new Set([
 const READ_BY_MARKUP = new Set([...READ_BY_A_TEMPLATE, "enum-member"]);
 /** One identifier, as the grammar of the analyzed language spells one. */
 const IDENTIFIER = /[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*/uy;
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /**
  * Every template under the configured directories, read once for the run, in path
  * order and each file once. A directory is named relative to the target root, and
@@ -48,34 +43,29 @@ function compare(a, b) {
 export function readTemplates(host, targetRoot, analysis) {
     const files = new Map();
     const read = (dir) => {
-        const entries = [...host.readDirectory(joinPath(targetRoot, dir))].sort((a, b) => compare(a.name, b.name));
-        for (const entry of entries) {
-            const path = joinPath(dir, entry.name);
-            if (entry.directory) {
-                read(path);
-                continue;
-            }
+        for (const below of filesBelow(host, joinPath(targetRoot, dir), () => true)) {
+            const path = joinPath(dir, below);
             const absolute = joinPath(targetRoot, path);
             if (!files.has(path) && host.kindOf(absolute) === "file") {
                 files.set(path, host.readFile(absolute));
             }
         }
     };
-    for (const configured of analysis.templateDirs) {
+    for (const configured of analysis.template_dirs) {
         const dir = normalizePath(configured);
         if (isAbsolutePath(dir) ||
             dir === ".." ||
             dir.startsWith("../") ||
             host.kindOf(joinPath(targetRoot, dir)) !== "directory") {
-            throw new ConfigError("malformed", "analysis.template_dirs", `analysis.template_dirs: ${JSON.stringify(configured)} is not a directory below the target root`);
+            throw new UsageError(`analysis.template_dirs: ${JSON.stringify(configured)} is not a directory below the target root`);
         }
         read(dir);
     }
     return {
-        delimiters: analysis.templateDelimiters,
+        delimiters: analysis.template_delimiters,
         files: [...files]
             .map(([path, text]) => ({ path, text }))
-            .sort((a, b) => compare(a.path, b.path)),
+            .sort((a, b) => bytewise(a.path, b.path)),
     };
 }
 /** The end of the quoted string that opens at `from`, past its closing quote. */

package/dist/src/tests/file-class.js

@@ -0,0 +1,76 @@
+/**
+ * The file classes the run counts references by. A test file is one a `ts.test_files`
+ * pattern or a test runner's row names (the test-runner entry source decides which), a test
+ * file no project holds, or a consumer's file a pattern names below the consumer's root.
+ * A test-support file is test code as well, decided once the references are known
+ * (`support.ts`), so a reference carries only whether a test file made it and the counters
+ * read the support class beside it.
+ */
+import { renderPosition } from "../position.js";
+import { bytewise } from "../text/compare.js";
+import { globExpression } from "../text/glob.js";
+/** The test files of the target: each file the test-runner source names, by its file name. */
+export function targetTestFile(named) {
+    return (file) => named.has(file.fileName);
+}
+/** The test files a pattern names, each by its path below `root`: a consumer's, below the consumer's root. */
+export function patternTestFile(patterns, root) {
+    const expressions = patterns.map(globExpression);
+    return (file) => {
+        const path = renderPosition(file, root, 0).path;
+        return expressions.some((expression) => expression.test(path));
+    };
+}
+/** The own files of a project that are test files, by their path below `root`, ascending. */
+export function testFilePaths(project, root, testFile) {
+    return project
+        .ownSourceFiles()
+        .filter(testFile)
+        .map((file) => renderPosition(file, root, 0).path)
+        .sort(bytewise);
+}
+/** Whether test code made one reference: a test file, or a test-support file of the target. */
+export function madeByTestCode(reference, support) {
+    return (reference.test || (reference.consumer === undefined && support.has(reference.position.path)));
+}
+/** Whether the mode classes a reference test code made as a test one: any but a loaded consumer's it classes as production. */
+export function classedAsTest(test, consumer, mode) {
+    return test && !(consumer && mode.consumerTestsProduction === true);
+}
+/** Whether a production mode counts no reference of this one: test code made it, as the mode classes it. */
+export function withheldBy(mode, reference, support) {
+    return (mode.production &&
+        classedAsTest(madeByTestCode(reference, support), reference.consumer !== undefined, mode));
+}
+/** Whether a production mode follows no edge like this one: {@link withheldBy} for a graph edge. */
+export function edgeWithheldBy(mode, edge) {
+    return mode.production && classedAsTest(edge.test, edge.consumer, mode);
+}
+/** 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) => bytewise(a.rule, b.rule));
+}

package/dist/src/{outside-tests.js → tests/outside.js}

@@ -7,15 +7,15 @@
  * it names is not known.
  */
 import { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { RESOLVED_EXTENSIONS } from "./configuration-files.js";
-import { emittedFrom } from "./emit-map.js";
-import { namesImported } from "./module-declarations.js";
-import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.js";
-import { renderPosition } from "./position.js";
-import { nameComponent } from "./ref.js";
+import { RESOLVED_EXTENSIONS } from "../entries/configuration-files.js";
+import { emittedFrom } from "../load/emit-map.js";
+import { namesImported } from "../import-bindings.js";
+import { dirnamePath, joinPath, normalizePath, queriedModulePath, startsRelativePath, } from "../paths.js";
+import { renderPosition } from "../position.js";
+import { nameComponent } from "../ref.js";
 /** The paths below the target root one relative specifier may name, written path first. */
 function candidates(dir, specifier) {
-    if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+    if (!startsRelativePath(specifier)) {
         return [];
     }
     const path = normalizePath(dir === "" ? specifier : `${dir}/${specifier}`);

package/dist/src/{test-support.js → tests/support.js}

@@ -5,8 +5,8 @@
  * another such file, so it is judged with the tests: what it references is referenced by
  * test code.
  */
-import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./convention-rows.js";
-import { packageOfSpecifier } from "./dependencies.js";
+import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES, } from "../entries/convention-rows.js";
+import { packageOfSpecifier } from "../dependencies.js";
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
 /**
@@ -14,7 +14,9 @@ const SKIP_ROOT = "type-error";
  * convention row reads test files for, and the convention table's test libraries.
  */
 const TEST_PACKAGES = new Set([
-    ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined).map((row) => row.package),
+    ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined ||
+        row.testDirectories !== undefined ||
+        row.testRunner !== undefined).map((row) => row.package),
     ...TEST_LIBRARIES,
 ]);
 /**
@@ -161,12 +163,3 @@ export function testSupportFiles(symbols, references, roots, testFiles, evidence
     const support = withoutOutsideUsers(new Set([...onlyTests].filter((path) => carries(onlyTests, path))));
     return { support, testUsed: new Set([...onlyTests].filter((path) => !support.has(path))) };
 }
-/** The references with every one a test-support file makes counted as a test reference. */
-export function supportReferences(references, support) {
-    if (support.size === 0) {
-        return references;
-    }
-    return references.map((reference) => !reference.test && support.has(reference.position.path)
-        ? { ...reference, test: true }
-        : reference);
-}

package/dist/src/text/compare.js

@@ -0,0 +1,26 @@
+/**
+ * Two strings in the order of their UTF-8 bytes, the order every set of a run is read in.
+ * That is code point order, which UTF-16 code unit order (`<` on strings) breaks above
+ * U+FFFF: a surrogate unit is below U+E000 while the code point it encodes is above U+FFFF.
+ */
+export function bytewise(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    const length = Math.min(a.length, b.length);
+    for (let at = 0; at < length; at += 1) {
+        const x = a.charCodeAt(at);
+        const y = b.charCodeAt(at);
+        if (x !== y) {
+            return ranked(x) < ranked(y) ? -1 : 1;
+        }
+    }
+    return a.length < b.length ? -1 : 1;
+}
+/** One UTF-16 unit moved so that a surrogate ranks above every unit of U+E000 to U+FFFF. */
+function ranked(unit) {
+    if (unit >= 0xe000) {
+        return unit - 0x800;
+    }
+    return unit >= 0xd800 ? unit + 0x2000 : unit;
+}