@cplieger/deadset-ts 5.1.1 → 5.2.1

package/dist/src/analysis.js

@@ -11,13 +11,13 @@ import { lineOf, readComponent } from "./component-files.js";
 import { consumerLoads, consumerReferences, moduleIdentity, } from "./consumers.js";
 import { configuredDeclarations, configuredRef, declarationsNamed, } from "./configured-declarations.js";
 import { decorator } from "./decorator.js";
-import { dependenciesOf, projectNeeds } from "./dependencies.js";
+import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.js";
 import { deprecatedDeclarations } from "./deprecation.js";
 import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "./discover.js";
 import { conventionFailuresFor, generatedFiles, readConventions, } from "./conventions.js";
 import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
-import { generatedFile } from "./generated-file.js";
+import { generatedFile, generatedFilesOf } from "./generated-file.js";
 import { sourceFilesOf } from "./source-files.js";
 import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
 import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
@@ -224,6 +224,7 @@ function readProjects(engine, host, scope, config, stage) {
                         ...kept.map((id) => ({ id, kind: "type-error", source: "" })),
                     ],
                 };
+            const own = sourceFilesOf(project, targetRoot);
             return {
                 configuration,
                 configFile: project.configFile,
@@ -235,7 +236,7 @@ function readProjects(engine, host, scope, config, stage) {
                     .ownSourceFiles()
                     .filter((file) => referenceOnly(file.fileName))
                     .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
-                generated: generatedFiles(conventions, sourceFilesOf(project, targetRoot)),
+                generated: generatedFilesOf(own, generatedFiles(conventions, own)),
             };
         };
         for (const file of project.ownSourceFiles()) {
@@ -276,6 +277,7 @@ function readProjects(engine, host, scope, config, stage) {
         unanswered: session.unanswered,
         componentsUnread: workspace?.componentsUnread ?? [],
         conventionsApplied: conventions.applied,
+        conventionUses: conventions.uses,
         outsideTests,
     };
 }
@@ -470,6 +472,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         unanswered: read.unanswered,
         componentsUnread: read.componentsUnread,
         conventionsApplied: read.conventionsApplied,
+        conventionUses: read.conventionUses,
     };
 }
 /**
@@ -646,7 +649,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
             references: one.configured.references,
             accessors: one.extra.accessors,
         })), swept.exempt, input.mode),
-        dependencies: dependenciesOf(host, targetRoot, projects.map((one) => one.extra.needs), swept.sweep.candidates.map((candidate) => candidate.id)),
+        dependencies: dependenciesOf(host, targetRoot, [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)], swept.sweep.candidates.map((candidate) => candidate.id)),
         implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
         files: {
             tree: sourceTree(host, targetRoot),

package/dist/src/config.js

@@ -49,9 +49,12 @@ export function defaultConfig() {
         ts: {
             testFiles: [
                 "**/*.test.{ts,tsx,mts,cts}",
+                "**/*.test-d.{ts,tsx,mts,cts}",
+                "**/*.spec-d.{ts,tsx,mts,cts}",
                 "**/*.spec.*",
                 "**/__tests__/**",
                 "**/__mocks__/**",
+                "**/test-d/**",
             ],
             entryFiles: [],
             componentExtensions: [".vue", ".svelte", ".astro"],

package/dist/src/configuration-files.js

@@ -164,33 +164,31 @@ function relativeSpecifiers(file) {
     });
 }
 /**
- * The module one relative specifier from a configuration file reaches: the path it names,
- * that path with its JavaScript extension replaced by the TypeScript counterparts, that
- * path with an extension appended, and a directory's `index` with one appended.
+ * The paths one relative specifier from a configuration file may reach, in the order they
+ * are tried: the path it names where that ends with a module extension, that path with its
+ * JavaScript extension replaced by the TypeScript counterparts, that path with an
+ * extension appended, and a directory's `index` with one appended. A data file such as
+ * `./package.json` is no module, so it is no candidate.
  */
-function reachedBy(host, dir, specifier) {
+export function specifierCandidates(dir, specifier) {
     const path = resolvePath(dir, specifier);
-    const isFile = (candidate) => host.kindOf(candidate) === "file";
-    // A data file such as `./package.json` is no module, so its strings use no dependency.
-    if (isFile(path) && APPENDED.some((extension) => path.endsWith(extension))) {
-        return path;
+    const candidates = [];
+    if (APPENDED.some((extension) => path.endsWith(extension))) {
+        candidates.push(path);
     }
     for (const [extension, counterparts] of COUNTERPARTS) {
         if (path.endsWith(extension)) {
             const stem = path.slice(0, -extension.length);
-            const found = counterparts.map((one) => stem + one).find(isFile);
-            if (found !== undefined) {
-                return found;
-            }
+            candidates.push(...counterparts.map((one) => stem + one));
         }
     }
-    const appended = APPENDED.map((extension) => path + extension).find(isFile);
-    if (appended !== undefined) {
-        return appended;
-    }
-    return host.kindOf(path) === "directory"
-        ? APPENDED.map((extension) => joinPath(path, `index${extension}`)).find(isFile)
-        : undefined;
+    candidates.push(...APPENDED.map((extension) => path + extension));
+    candidates.push(...APPENDED.map((extension) => joinPath(path, `index${extension}`)));
+    return candidates;
+}
+/** The file on disk one relative specifier from a configuration file reaches, or undefined. */
+export function resolveRelativeSpecifier(host, dir, specifier) {
+    return specifierCandidates(dir, specifier).find((path) => host.kindOf(path) === "file");
 }
 /**
  * The configuration modules of the directories that hold a manifest which the program
@@ -233,7 +231,7 @@ function outsideModules(host, dirs, files, holdsManifest, parse) {
         const file = parse(next.path, text);
         found.push({ file, manifestDir: next.manifestDir });
         for (const specifier of relativeSpecifiers(file)) {
-            const reached = reachedBy(host, dirnamePath(next.path), specifier);
+            const reached = resolveRelativeSpecifier(host, dirnamePath(next.path), specifier);
             if (reached !== undefined) {
                 pending.push({ path: reached, manifestDir: next.manifestDir });
             }
@@ -267,12 +265,13 @@ export function dependenciesNamed(text, declared) {
     return declared.filter((name) => text === name || text.startsWith(`${name}/`));
 }
 /**
- * The own files one string names read against a directory: none unless it starts with
- * `./` or `../`, else the file it names directly or through the emit mapping, or the
- * file it names with an extension the module resolution appends.
+ * The own files one string names read against a directory: the file it names directly or
+ * through the emit mapping, or the file it names with an extension the module resolution
+ * appends. An empty string, one starting with `/` and one holding a glob character names
+ * none.
  */
 export function filesNamedBy(files, dir, text) {
-    if (!RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix)) || text.includes("*")) {
+    if (text === "" || text.startsWith("/") || /[*?[{]/u.test(text)) {
         return [];
     }
     const path = resolvePath(dir, text);

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "2.2.0",
+        corpusVersion: "3.0.0",
         result: "pass",
-        digest: "sha256:ce7c9087ed7b2baf3de9fa2df436b500706f4f9e94fd9e0fed633054305f06a4",
+        digest: "sha256:db52e3164347cab70f45f438b4ac9ce89573be9303503daeb237a3c40361b001",
     },
     gaps: [],
 };

package/dist/src/contextual-uses.js

@@ -39,6 +39,7 @@ function propertyName(property) {
  */
 export function contextualUses(project, held, chains, literals, flows, cap, properties) {
     const queries = project.queries;
+    const ownPaths = project.ownPaths();
     const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
     let batches = 0;
     let lookups = 0;
@@ -78,6 +79,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                     .declarationsOf(property)
                     .filter((id) => MEMBER_KINDS.has(kinds.get(id) ?? "file")),
                 handles: new Set(property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`)),
+                own: property.declarations.some((handle) => ownPaths.has(handle.path)),
             });
         }
         tables.set(type.id, table);
@@ -109,6 +111,11 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     /** The members a position may read structurally: those of object types, not of classes. */
     const readable = (member) => member.ids.filter((id) => kinds.get(id) === "type-member");
     const carries = (part) => [...membersOf(part).values()].some((member) => readable(member).length > 0);
+    /** Whether an object type has members and declares none of them in the target. */
+    const outside = (part) => {
+        const members = [...membersOf(part).values()];
+        return members.length > 0 && members.every((member) => !member.own);
+    };
     const elements = new Map();
     /** The element type of an array type, read once per type. */
     const elementOf = (type) => {
@@ -168,7 +175,10 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const sources = partsOf(source).filter((one) => !targets.some((part) => part.id === one.id));
         for (const one of sources) {
             if (carries(one)) {
-                into.push({ source: one, targets });
+                into.push({ source: one, targets, outside: false });
+            }
+            else if (outside(one)) {
+                into.push({ source: one, targets, outside: true });
             }
             const element = elementOf(one);
             const called = element === undefined ? callOf(one) : undefined;
@@ -198,7 +208,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
         seen.add(type.id);
         return partsOf(type).some((part) => {
-            if (carries(part)) {
+            if (carries(part) || outside(part)) {
                 return true;
             }
             const element = elementOf(part);
@@ -223,9 +233,20 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const checked = [];
         compared(type, position, checked, new Set());
         const ids = new Set();
-        for (const { source, targets } of checked) {
+        for (const { source, targets, outside: held } of checked) {
             const tables = targets.map(membersOf);
-            for (const [name, member] of membersOf(source)) {
+            const sourceMembers = membersOf(source);
+            if (held) {
+                for (const table of tables) {
+                    for (const [name, member] of table) {
+                        if (sourceMembers.has(name)) {
+                            member.ids.forEach((id) => ids.add(id));
+                        }
+                    }
+                }
+                continue;
+            }
+            for (const [name, member] of sourceMembers) {
                 const read = tables.some((table) => {
                     const declared = table.get(name);
                     return (declared !== undefined &&

package/dist/src/convention-rows.js

@@ -385,5 +385,12 @@ export const CONVENTION_ROWS = [
             `**/{vitest,vite}.*.config.${ANY_MODULE}`,
         ],
         moves: [],
+        shortNames: [
+            {
+                property: "test.coverage.provider",
+                files: [`{vitest,vite}.config.${ANY_MODULE}`],
+                package: "@vitest/coverage-{}",
+            },
+        ],
     },
 ];

package/dist/src/conventions.js

@@ -5,7 +5,7 @@
  * directory a configuration property moves read from the property's literal value.
  * No configuration file is run.
  */
-import { isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { lineOf } from "./component-files.js";
 import { CONVENTION_ROWS, } from "./convention-rows.js";
 import { globExpression } from "./glob.js";
@@ -288,12 +288,32 @@ function objectOf(node, declared, throughCalls, seen = new Set()) {
     }
     return at;
 }
+/** The text of a string literal or a template literal with no substitution, or undefined. */
+function literalText(node) {
+    const at = unwrapped(node);
+    return isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at) ? at.text : undefined;
+}
+/**
+ * The literal texts one value at a path's end writes: the literal itself, or, where
+ * `elements`, each element of an array literal of literals. Undefined for any other value.
+ */
+function literalTexts(held, elements) {
+    const one = literalText(held);
+    if (one !== undefined) {
+        return [one];
+    }
+    if (!elements || !isArrayLiteralExpression(held)) {
+        return undefined;
+    }
+    const texts = held.elements.map(literalText);
+    return texts.every((text) => text !== undefined) ? texts : undefined;
+}
 /**
  * Reads the values at one path of keys below one object literal into `values`, and
  * answers the first member that does not write its value out: a spread, a value that is
  * not a literal at the path's end, or one that is not an object literal before it.
  */
-function readPath(object, keys, values) {
+function readPath(object, keys, values, elements) {
     const [key, ...rest] = keys;
     for (const member of object.properties) {
         if (isSpreadAssignment(member) || computesKey(member)) {
@@ -304,16 +324,17 @@ function readPath(object, keys, values) {
         }
         const held = isPropertyAssignment(member) ? unwrapped(member.initializer) : undefined;
         if (rest.length === 0) {
-            if (held === undefined || !(isStringLiteral(held) || isNoSubstitutionTemplateLiteral(held))) {
+            const texts = held === undefined ? undefined : literalTexts(held, elements);
+            if (texts === undefined) {
                 return member;
             }
-            values.push(held.text);
+            values.push(...texts);
         }
         else {
             if (held === undefined || !isObjectLiteralExpression(held)) {
                 return member;
             }
-            const failed = readPath(held, rest, values);
+            const failed = readPath(held, rest, values, elements);
             if (failed !== undefined) {
                 return failed;
             }
@@ -324,11 +345,12 @@ function readPath(object, keys, values) {
 /**
  * Every value one file writes at one property's path inside the object it is read from:
  * the options argument of every call `call` names, or the file's default export. A string
- * literal or a template literal with no substitution is the value. A read object, or an
- * object along the path, that is not written out as an object literal, or that spreads
- * another object into itself, is not a literal, and neither is any other value at the path.
+ * literal or a template literal with no substitution is the value, and so is each element
+ * of an array literal of them where `elements`. A read object, or an object along the
+ * path, that is not written out as an object literal, or that spreads another object into
+ * itself, is not a literal, and neither is any other value at the path.
  */
-export function readProperty(file, property, call) {
+export function readProperty(file, property, call, elements = false) {
     const declared = declaredValues(file);
     const objects = call === undefined
         ? defaultExports(file).map((one) => objectOf(one, declared, true))
@@ -339,7 +361,7 @@ export function readProperty(file, property, call) {
             continue;
         }
         const notLiteral = isObjectLiteralExpression(object)
-            ? readPath(object, property.split("."), values)
+            ? readPath(object, property.split("."), values, elements)
             : object;
         if (notLiteral !== undefined) {
             return { values, notLiteral };
@@ -392,29 +414,18 @@ function configurationFiles(host, dir, glob) {
 function resolveMove(host, parse, dir, row, move, resolved) {
     const set = [];
     for (const reading of move.readings) {
-        for (const glob of reading.files) {
-            for (const name of configurationFiles(host, dir, glob)) {
-                const path = joinPath(dir, name);
-                let text;
-                try {
-                    text = host.readFile(path);
-                }
-                catch {
-                    continue;
-                }
-                const file = parse(path, text);
-                const read = readProperty(file, reading.property, reading.call);
-                if (read.notLiteral !== undefined) {
-                    const line = lineOf(text, read.notLiteral.getStart());
-                    return {
-                        failure: `${name}:${String(line)} sets ${reading.property}, which moves a directory ` +
-                            `the convention row ${row.name} reads, to a value that is not a string literal: ` +
-                            `write it as a literal, or name ${row.name} in ts.disabled_conventions and its ` +
-                            `files in ts.entry_files`,
-                    };
-                }
-                set.push(...read.values);
+        for (const { name, text, file } of readingFiles(host, parse, dir, reading.files)) {
+            const read = readProperty(file, reading.property, reading.call);
+            if (read.notLiteral !== undefined) {
+                const line = lineOf(text, read.notLiteral.getStart());
+                return {
+                    failure: `${name}:${String(line)} sets ${reading.property}, which moves a directory ` +
+                        `the convention row ${row.name} reads, to a value that is not a string literal: ` +
+                        `write it as a literal, or name ${row.name} in ts.disabled_conventions and its ` +
+                        `files in ts.entry_files`,
+                };
             }
+            set.push(...read.values);
         }
     }
     const dirs = [];
@@ -427,6 +438,55 @@ function resolveMove(host, parse, dir, row, move, resolved) {
     }
     return { dirs: [...new Set(dirs)] };
 }
+/** The texts each configuration file a reading names holds, parsed, in name order. */
+function readingFiles(host, parse, dir, files) {
+    const found = [];
+    for (const glob of files) {
+        for (const name of configurationFiles(host, dir, glob)) {
+            const path = joinPath(dir, name);
+            let text;
+            try {
+                text = host.readFile(path);
+            }
+            catch {
+                continue;
+            }
+            found.push({ name, text, file: parse(path, text) });
+        }
+    }
+    return found;
+}
+/**
+ * The dependencies one manifest declares that an applied row's short names use: the
+ * package each literal value stands for, and, for a value that is not a literal, every
+ * declared dependency the row's package name stands for with some value.
+ */
+function shortNameUses(host, parse, dir, manifest, readings) {
+    const declared = new Set(DEPENDENCY_SECTIONS.flatMap((section) => {
+        const held = isRecord(manifest) ? manifest[section] : undefined;
+        return isRecord(held) ? Object.keys(held) : [];
+    }));
+    const used = new Set();
+    for (const reading of readings) {
+        const [before = "", after = ""] = reading.package.split("{}");
+        for (const { file } of readingFiles(host, parse, dir, reading.files)) {
+            const read = readProperty(file, reading.property, reading.call, true);
+            for (const value of read.values) {
+                used.add(`${before}${value}${after}`);
+            }
+            if (read.notLiteral !== undefined) {
+                for (const name of declared) {
+                    if (name.length >= before.length + after.length &&
+                        name.startsWith(before) &&
+                        name.endsWith(after)) {
+                        used.add(name);
+                    }
+                }
+            }
+        }
+    }
+    return [...used].filter((name) => declared.has(name)).sort(compare);
+}
 /** Two strings ordered bytewise. */
 function compare(a, b) {
     if (a === b) {
@@ -443,6 +503,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
     const globs = [];
     const generated = [];
     const failures = [];
+    const uses = new Set();
     for (const manifest of manifests) {
         const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
         const versions = new Map();
@@ -500,6 +561,9 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
                 version,
                 manifest: manifest.path,
             });
+            for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
+                uses.add(name);
+            }
             const excludes = [
                 ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
             ].map(globExpression);
@@ -520,7 +584,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
     unique.sort((a, b) => compare(a.name, b.name) ||
         compare(a.manifest, b.manifest) ||
         compare(JSON.stringify(a), JSON.stringify(b)));
-    return { applied: unique, globs, generated, failures };
+    return { applied: unique, globs, generated, failures, uses: [...uses].sort(compare) };
 }
 /**
  * Every own file of one project below a directory an applied row names as generated, by

package/dist/src/dependencies.js

@@ -24,6 +24,14 @@ const SECTIONS = [
 ];
 /** The owner of a use no declaration of the inventory holds: a configuration's. */
 const PROJECT_OWNER = "";
+/** What a configuration's own reading needs: packages no deletion of a declaration removes. */
+export function configurationNeeds(packages) {
+    return {
+        packages: new Set(packages),
+        uses: new Map([[PROJECT_OWNER, new Set(packages)]]),
+        unanswered: false,
+    };
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/src/entry-point-gaps.js

@@ -13,9 +13,9 @@ const EVERY_CONVENTION = "every file it loads by its own convention beyond its c
 const UNREAD = "No rule reads it beyond a configuration file the file-name form or a string enters, so a " +
     "file only it loads is reported as never imported unless ts.entry_files or roots.patterns " +
     "names it.";
-/** Why a configuration's file names that are not relative literals are declined. */
-const NOT_RELATIVE = "A string of a configuration file names a file only where it is a literal starting with ./ " +
-    "or ../, so a file named otherwise is reported as never imported.";
+/** Why a configuration's file names that are not literals are declined. */
+const NOT_LITERAL = "A string of a configuration file names a file only where it is a literal, so a file a " +
+    "computed value names is reported as never imported.";
 /** The tools whose own conventions are not read. */
 const UNREAD_TOOLS = [
     "angular",
@@ -211,11 +211,6 @@ const PARTLY_ENTERED = [
         reason: "A testMatch that is not a string literal leaves the test-file set unknown, and an " +
             "unknown set enters nothing.",
     },
-    {
-        tool: "playwright",
-        convention: "a globalSetup or globalTeardown file named without a leading ./ or ../",
-        reason: NOT_RELATIVE,
-    },
     {
         tool: "playwright",
         convention: "the testDir and testMatch of an entry in projects",
@@ -272,20 +267,14 @@ const PARTLY_ENTERED = [
     },
     {
         tool: "vite",
-        convention: "an entry point its configuration names without a leading ./ or ../, or computes",
-        reason: NOT_RELATIVE,
-    },
-    {
-        tool: "vite",
-        convention: "the module scripts an index.html loads",
-        reason: "No rule reads an HTML file, so a script only index.html loads is reported as never " +
-            "imported unless ts.entry_files names it.",
+        convention: "an entry point its configuration computes",
+        reason: NOT_LITERAL,
     },
     {
         tool: "vitest",
-        convention: "the benchmark and type-test files",
-        reason: "A test file is one ts.test_files classifies, so a *.bench.* or *.test-d.* file is " +
-            "entered only where a configured pattern names it.",
+        convention: "the benchmark files",
+        reason: "A test file is one ts.test_files classifies, so a *.bench.* file is entered only " +
+            "where a configured pattern names it.",
     },
     {
         tool: "vitest",
@@ -293,11 +282,6 @@ const PARTLY_ENTERED = [
         reason: "A string is read against the configuration file's directory, so a setup file named " +
             "against a root the configuration moves is not entered.",
     },
-    {
-        tool: "vitest",
-        convention: "a setup file named without a leading ./ or ../",
-        reason: NOT_RELATIVE,
-    },
     {
         tool: "vitest",
         convention: "the test files a configuration's include member names",
@@ -306,8 +290,8 @@ const PARTLY_ENTERED = [
     },
     {
         tool: "webpack",
-        convention: "an entry point its configuration names without a leading ./ or ../, or computes",
-        reason: NOT_RELATIVE,
+        convention: "an entry point its configuration computes",
+        reason: NOT_LITERAL,
     },
 ];
 /** Two strings ordered bytewise. */

package/dist/src/entry-points.js

@@ -14,6 +14,7 @@ import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAss
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.js";
 import { globExpression } from "./glob.js";
+import { htmlEntries } from "./html-entries.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 /** The extensions the test runner and the browser-test runner load a configuration from. */
@@ -406,5 +407,8 @@ export function entryPoints(project, files, testFiles, host, targetRoot, parse)
         }
         found.push(...workersOf(project, file, files));
     }
+    for (const { file, source } of htmlEntries(host, targetRoot, files, parse)) {
+        found.push({ file, rule: "html-entry", source, exports: true });
+    }
     return found;
 }

package/dist/src/findings/completion.js

@@ -39,23 +39,29 @@ function publishedIds(union) {
 }
 /**
  * The reachability class of one declaration of the run. A declaration of a library's
- * published API, a public member of a published type included, has callers outside the
- * target: it is `certain` where the run loaded every consumer the scope declared and
- * declared at least one, `probable` where it declared consumers and did not load them
- * all, and `possible` where it declared none. Whether the configuration declares the
- * consumer set complete decides nothing here. Every other declaration has every reference
- * in the loaded program, a private member and a `#private` name among them, and is
- * `certain`.
+ * published API, a public member of a published type included, is `certain` where the
+ * run loaded every consumer the scope declared and declared one, `probable` where one did
+ * not load, and `possible` where it declared none, whatever the configuration says of the
+ * consumer set. A declaration of test-support code that test code references, outside the
+ * test-of-dead-code rule, is `possible`. Every other declaration is `certain`.
  */
 function reachabilityClasses(input) {
     const published = publishedIds(input.swept.matrix.union);
+    const usedByTests = new Set(input.swept.sweep.candidates
+        .filter((candidate) => candidate.heldByTests === candidate.id)
+        .map((candidate) => candidate.id));
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
         ? "possible"
         : everyDeclaredLoaded(input.boundary)
             ? "certain"
             : "probable";
-    return (id) => (published.has(id) ? outside : "certain");
+    return (id) => {
+        if (usedByTests.has(id)) {
+            return "possible";
+        }
+        return published.has(id) ? outside : "certain";
+    };
 }
 /**
  * The component each dead declaration of the run falls in, and none for a live one, with
@@ -117,6 +123,12 @@ export function completed(input, findings, kinds = KINDS) {
     const componentOf = findingComponents(swept, input.config.reporters.cascade);
     let minted = swept.sweep.components.length;
     const dead = new Set(swept.sweep.components.map((component) => component.id));
+    const fallingWith = new Map();
+    for (const { heldByTests } of swept.sweep.candidates) {
+        if (heldByTests !== undefined) {
+            fallingWith.set(heldByTests, (fallingWith.get(heldByTests) ?? 0) + 1);
+        }
+    }
     const done = findings.map((finding) => {
         const row = kinds.get(finding.code);
         if (row === undefined) {
@@ -134,8 +146,12 @@ export function completed(input, findings, kinds = KINDS) {
         const judged = !part && union.subject[at] === true ? symbol : undefined;
         const candidate = judged === undefined ? undefined : candidates.get(judged.id);
         const found = symbol === undefined || part ? undefined : componentOf(symbol.id);
-        // A test file's declaration is a component member only as a test of dead code.
-        if (candidate !== undefined && found === undefined && union.test[at] !== true) {
+        // A test file's declaration is a component member only as a test of dead code, and
+        // test code keeps the test-support code it references out of every component.
+        if (candidate !== undefined &&
+            found === undefined &&
+            union.test[at] !== true &&
+            candidate.heldByTests === undefined) {
             throw new Error(`${candidate.id} is judged dead and falls in no dead component`);
         }
         let component = found;
@@ -144,7 +160,7 @@ export function completed(input, findings, kinds = KINDS) {
             component = {
                 id: componentId(minted),
                 root: true,
-                symbolCount: 1,
+                symbolCount: symbol?.kind === "interface" ? (fallingWith.get(symbol.id) ?? 1) : 1,
                 deletableLines: 0,
             };
         }