@cplieger/deadset-ts 7.0.0-dev.1 → 7.0.0-dev.3

package/dist/src/configuration-files.js

@@ -50,10 +50,16 @@ export const RESOLVED_EXTENSIONS = [
     ".mjs",
     ".cjs",
 ];
+/** The directory a package manager installs packages into, whose files are no project's own. */
+const MODULES_DIR = "node_modules";
 /** The file's name, the last segment of its path. */
 function basename(path) {
     return path.slice(path.lastIndexOf("/") + 1);
 }
+/** Whether one path is the project's own: below the target root and in no `node_modules`. */
+function isProjectPath(root, path) {
+    return relativePath(root, path)?.split("/").includes(MODULES_DIR) === false;
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -65,6 +71,160 @@ export function configurationModuleForm(name) {
 export function isConfigurationDocumentName(name) {
     return DOCUMENT_NAME.test(name);
 }
+/** The flags a tool's command line names its configuration file with. */
+const CONFIG_FLAGS = new Set(["--config", "-c"]);
+/** The extensions of a module a configuration flag may name. */
+const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+/** The characters that end a word outside quotes and separate nothing: blanks. */
+const BLANK = /[ \t\r\f\v]/u;
+/** The characters that end a word outside quotes and begin an operator: newline included. */
+const OPERATOR = /[\n;&|()<>]/u;
+/** The characters a backslash escapes inside double quotes; before any other it stands for itself. */
+const DOUBLE_QUOTE_ESCAPES = new Set(["$", "`", '"', "\\"]);
+/**
+ * The words of one command line, as POSIX token recognition reads quotes, backslashes,
+ * line continuations, comments and operators. A word an expansion may change (an unquoted
+ * `$`, backquote, glob character or leading `~`, or a `$` or backquote in double quotes)
+ * is computed, and so is the rest of a line whose quote is never closed. A computed word
+ * and each operator are undefined, so a flag's file is never read across them.
+ */
+function shellWords(command) {
+    const words = [];
+    let word;
+    let computed = false;
+    const end = () => {
+        if (word !== undefined) {
+            words.push(computed ? undefined : word);
+        }
+        word = undefined;
+        computed = false;
+    };
+    for (let at = 0; at < command.length; at += 1) {
+        const char = command.charAt(at);
+        if (char === "\\" && command.charAt(at + 1) === "\n") {
+            at += 1;
+        }
+        else if (BLANK.test(char)) {
+            end();
+        }
+        else if (OPERATOR.test(char)) {
+            end();
+            words.push(undefined);
+        }
+        else if (char === "#" && word === undefined) {
+            const newline = command.indexOf("\n", at);
+            at = newline < 0 ? command.length : newline - 1;
+        }
+        else if (char === "\\") {
+            at += 1;
+            word = (word ?? "") + command.charAt(at);
+        }
+        else if (char === "'" || char === '"') {
+            const close = closingQuote(command, at);
+            if (close < 0) {
+                word ??= "";
+                computed = true;
+                break;
+            }
+            const quoted = char === "'"
+                ? { text: command.slice(at + 1, close), computed: false }
+                : doubleQuoted(command.slice(at + 1, close));
+            word = (word ?? "") + quoted.text;
+            computed ||= quoted.computed;
+            at = close;
+        }
+        else {
+            computed ||= /[$`*?[]/u.test(char) || (char === "~" && word === undefined);
+            word = (word ?? "") + char;
+        }
+    }
+    end();
+    return words;
+}
+/** The text between one pair of double quotes, unescaped, and whether an expansion may change it. */
+function doubleQuoted(inner) {
+    let text = "";
+    let computed = false;
+    for (let at = 0; at < inner.length; at += 1) {
+        const char = inner.charAt(at);
+        const next = inner.charAt(at + 1);
+        if (char === "\\" && next === "\n") {
+            at += 1;
+        }
+        else if (char === "\\" && DOUBLE_QUOTE_ESCAPES.has(next)) {
+            text += next;
+            at += 1;
+        }
+        else {
+            computed ||= char === "$" || char === "`";
+            text += char;
+        }
+    }
+    return { text, computed };
+}
+/** The index of the quote that closes the one at `open`, or -1 where none does. */
+function closingQuote(command, open) {
+    const quote = command.charAt(open);
+    for (let at = open + 1; at < command.length; at += 1) {
+        const char = command.charAt(at);
+        if (char === quote) {
+            return at;
+        }
+        if (quote === '"' && char === "\\") {
+            at += 1;
+        }
+    }
+    return -1;
+}
+/**
+ * The files the scripts of the manifest in one directory name after a configuration flag,
+ * `--config <file>`, `-c <file>` or `--config=<file>`, each a JSON file or a module below
+ * the target root and in no `node_modules`.
+ */
+function scriptConfigurations(host, root, dir) {
+    let scripts;
+    try {
+        const manifest = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
+        scripts = isRecord(manifest) ? manifest["scripts"] : undefined;
+    }
+    catch {
+        return [];
+    }
+    if (!isRecord(scripts)) {
+        return [];
+    }
+    const found = [];
+    for (const command of Object.values(scripts)) {
+        if (typeof command !== "string") {
+            continue;
+        }
+        const words = shellWords(command);
+        words.forEach((word, at) => {
+            const named = word !== undefined && CONFIG_FLAGS.has(word)
+                ? words[at + 1]
+                : word === undefined
+                    ? undefined
+                    : /^--config=(.+)$/su.exec(word)?.[1];
+            const path = named === undefined ? undefined : resolvePath(dir, named);
+            if (path !== undefined &&
+                [".json", ...MODULE_EXTENSIONS].some((extension) => path.endsWith(extension)) &&
+                isProjectPath(root, path) &&
+                host.kindOf(path) === "file") {
+                found.push(path);
+            }
+        });
+    }
+    return found;
+}
+/** The decoded value of one JSON file, or undefined where it cannot be read or parsed. */
+function readDocument(host, path) {
+    try {
+        return JSON.parse(host.readFile(path));
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Every string value one decoded JSON value holds at any depth. */
 export function documentStrings(value) {
     if (typeof value === "string") {
@@ -116,7 +276,8 @@ export function configurationFiles(host, targetRoot, files, parse) {
             dirs.add(dir);
         }
     }
-    const documents = [];
+    const pending = [];
+    const named = [];
     for (const dir of [...dirs].sort()) {
         if (!holdsManifest(dir)) {
             continue;
@@ -130,24 +291,57 @@ export function configurationFiles(host, targetRoot, files, parse) {
                 .sort();
         }
         catch {
-            continue;
+            names = [];
         }
-        for (const name of names) {
-            const path = joinPath(dir, name);
-            let value;
-            try {
-                value = JSON.parse(host.readFile(path));
+        pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
+        for (const path of scriptConfigurations(host, root, dir)) {
+            const held = files.byName.get(path);
+            if (path.endsWith(".json")) {
+                pending.push({ path, manifestDir: dir });
             }
-            catch {
+            else if (held !== undefined) {
+                modules.push({ file: held, form: "a script's configuration flag" });
+            }
+            else {
+                named.push({ path, manifestDir: dir });
+            }
+        }
+    }
+    // A document reached from two manifests is read against each, so a chain is keyed by both.
+    const documents = new Map();
+    const unreadable = new Set();
+    for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+        let document = documents.get(next.path);
+        if (unreadable.has(next.path) || document?.manifestDirs.includes(next.manifestDir) === true) {
+            continue;
+        }
+        if (document === undefined) {
+            const value = readDocument(host, next.path);
+            if (value === undefined) {
+                unreadable.add(next.path);
                 continue;
             }
-            documents.push({ path, strings: documentStrings(value) });
+            document = { path: next.path, manifestDirs: [], strings: documentStrings(value) };
+            documents.set(next.path, document);
+        }
+        document.manifestDirs.push(next.manifestDir);
+        for (const text of document.strings) {
+            const path = RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix))
+                ? resolvePath(dirnamePath(next.path), text)
+                : undefined;
+            if (path?.endsWith(".json") === true &&
+                isProjectPath(root, path) &&
+                host.kindOf(path) === "file") {
+                pending.push({ path, manifestDir: next.manifestDir });
+            }
         }
     }
     return {
         modules,
-        documents,
-        outside: parse === undefined ? [] : outsideModules(host, [...dirs], files, holdsManifest, parse),
+        documents: [...documents.values()],
+        outside: parse === undefined
+            ? []
+            : outsideModules(host, root, [...dirs], files, holdsManifest, parse, named),
     };
 }
 /** The relative specifiers one file's imports and re-exports name. */
@@ -192,11 +386,11 @@ export function resolveRelativeSpecifier(host, dir, specifier) {
 }
 /**
  * The configuration modules of the directories that hold a manifest which the program
- * does not hold, and the files they import by a relative specifier, until no further
- * file joins. A file that cannot be read is skipped.
+ * does not hold, and the project files below `root` they import by a relative specifier,
+ * until no further file joins. A file that cannot be read is skipped.
  */
-function outsideModules(host, dirs, files, holdsManifest, parse) {
-    const pending = [];
+function outsideModules(host, root, dirs, files, holdsManifest, parse, named) {
+    const pending = [...named];
     for (const dir of [...dirs].sort()) {
         if (!holdsManifest(dir)) {
             continue;
@@ -214,30 +408,36 @@ function outsideModules(host, dirs, files, holdsManifest, parse) {
         }
         pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
     }
-    const found = [];
-    const seen = new Set();
+    const found = new Map();
+    const unreadable = new Set();
     for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-        if (seen.has(next.path) || files.byName.has(next.path)) {
+        let outside = found.get(next.path);
+        if (unreadable.has(next.path) ||
+            files.byName.has(next.path) ||
+            outside?.manifestDirs.includes(next.manifestDir) === true) {
             continue;
         }
-        seen.add(next.path);
-        let text;
-        try {
-            text = host.readFile(next.path);
-        }
-        catch {
-            continue;
+        if (outside === undefined) {
+            let text;
+            try {
+                text = host.readFile(next.path);
+            }
+            catch {
+                unreadable.add(next.path);
+                continue;
+            }
+            outside = { file: parse(next.path, text), manifestDirs: [] };
+            found.set(next.path, outside);
         }
-        const file = parse(next.path, text);
-        found.push({ file, manifestDir: next.manifestDir });
-        for (const specifier of relativeSpecifiers(file)) {
+        outside.manifestDirs.push(next.manifestDir);
+        for (const specifier of relativeSpecifiers(outside.file)) {
             const reached = resolveRelativeSpecifier(host, dirnamePath(next.path), specifier);
-            if (reached !== undefined) {
+            if (reached !== undefined && isProjectPath(root, reached)) {
                 pending.push({ path: reached, manifestDir: next.manifestDir });
             }
         }
     }
-    return found;
+    return [...found.values()];
 }
 /** Every dependency the manifest in one directory declares, or none where it holds none to read. */
 export function declaredIn(host, dir) {

package/dist/src/conformance-record.js

@@ -4,7 +4,7 @@ export const RECORD = {
     conformance: {
         corpusVersion: "5.0.0",
         result: "pass",
-        digest: "sha256:26c486907df44fb8eaf3f749f60a6010ac94e7cfeeda70c4aa406445193ab80a",
+        digest: "sha256:c46c7d06b6f0c58504c5f311870efefc0b85f18c2c46ba7d7b722081cb370c0c",
     },
     gaps: [],
 };

package/dist/src/contextual-uses.js

@@ -3,10 +3,10 @@
  * An object-literal property writes the member of its name on each constituent of the
  * literal's contextual type that declares one. A value reaching a position typed by another
  * object type reads each of its members that type declares, through array elements and
- * function parameters and results too; a class instance there is the
- * interface-satisfaction class's evidence instead.
+ * the parameters and results of functions and constructors too; a class instance there is
+ * the interface-satisfaction class's evidence instead.
  */
-import { isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { isClassDeclaration, isClassExpression, isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isMethodSignatureDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, } from "@typescript/native/unstable/ast";
 import { SignatureKind } from "@typescript/native/unstable/sync";
 import { isAnswered } from "./query.js";
 /** The member kinds a contextual type writes and reads: data members and the members of object types. */
@@ -36,6 +36,20 @@ function propertyName(property) {
     }
     return undefined;
 }
+/**
+ * Whether an object spread copies a member a declaration declares: a method, a method
+ * signature and a class's accessor are no own data property of the value, while an
+ * accessor of an interface or a type literal describes one. It is decided on the
+ * declaration, because a mapped type over a class keeps the class's declarations on
+ * plain property symbols.
+ */
+function copiedBySpread(node) {
+    if (isMethodDeclaration(node) || isMethodSignatureDeclaration(node)) {
+        return false;
+    }
+    return !((isGetAccessorDeclaration(node) || isSetAccessorDeclaration(node)) &&
+        (isClassDeclaration(node.parent) || isClassExpression(node.parent)));
+}
 /**
  * The contextual uses of one project's literals and values, asked in batches: one
  * contextual type per literal and per value whose type carries a member of the target,
@@ -45,6 +59,9 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     const queries = project.queries;
     const ownPaths = project.ownPaths();
     const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
+    const privateNames = new Set(held.symbols
+        .filter((symbol) => symbol.visibility === "private-name")
+        .map((symbol) => symbol.id));
     let batches = 0;
     let lookups = 0;
     const batchesOf = (count) => Math.ceil(count / cap);
@@ -82,8 +99,12 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                 ids: chains
                     .declarationsOf(property)
                     .filter((id) => MEMBER_KINDS.has(kinds.get(id) ?? "file")),
+                methods: chains
+                    .declarationsOf(property)
+                    .filter((id) => kinds.get(id) === "interface-method"),
                 handles: new Set(property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`)),
                 own: property.declarations.some((handle) => ownPaths.has(handle.path)),
+                declarations: property.declarations.filter((handle) => ownPaths.has(handle.path)),
             });
         }
         tables.set(type.id, table);
@@ -133,7 +154,10 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     batches += batchesOf(carried.length);
     const types = queries.typesAt(carried.map((flow) => flow.value), cap);
     /** 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 readable = (member) => [
+        ...member.ids.filter((id) => kinds.get(id) === "type-member"),
+        ...member.methods,
+    ];
     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) => {
@@ -157,14 +181,36 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         elements.set(type.id, element);
         return element;
     };
+    const argumentsOf = new Map();
+    /** The type arguments of an instantiation of a generic type, read once per type. */
+    const typeArgumentsOf = (type) => {
+        const known = argumentsOf.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        lookups += type.isTypeReference() ? 1 : 0;
+        const held = queries.typeArguments(type);
+        const found = isAnswered(held) ? held : [];
+        argumentsOf.set(type.id, found);
+        return found;
+    };
     const calls = new Map();
-    /** The parameter and return types of a type's one call signature, read once per type. */
+    /**
+     * The parameter and return types of a type's one call signature, or of its one construct
+     * signature where it has no call signature, read once per type.
+     */
     const callOf = (type) => {
         if (calls.has(type.id)) {
             return calls.get(type.id);
         }
         lookups += 1;
-        const signatures = queries.signaturesOf(type, SignatureKind.Call);
+        let kind = SignatureKind.Call;
+        let signatures = queries.signaturesOf(type, kind);
+        if (isAnswered(signatures) && signatures.length === 0) {
+            lookups += 1;
+            kind = SignatureKind.Construct;
+            signatures = queries.signaturesOf(type, kind);
+        }
         let called;
         const [signature, ...more] = isAnswered(signatures) ? signatures : [];
         if (signature !== undefined && more.length === 0) {
@@ -172,6 +218,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             const result = queries.returnTypeOf(signature);
             lookups += parameters.length + 1;
             called = {
+                kind,
                 parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
                 result: isAnswered(result) ? result : undefined,
             };
@@ -181,10 +228,11 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     };
     /**
      * Each object type a value of `source` is checked as against the object types of
-     * `target`: the value's own, and through array elements and through a function's
-     * parameters, checked the other way, and its result. A source that is one of the
-     * target's own object types matches it as it stands. Each pair is compared once, which
-     * ends the walk over a recursive type.
+     * `target`: the value's own, and through array elements, a function's parameters,
+     * checked the other way, and result, and the type arguments two instantiations share
+     * by place, an array among them, as an array reaches `Iterable<T>`.
+     * A source that is one of the target's own object types matches it as it stands. Each
+     * pair is compared once, which ends the walk over a recursive type.
      */
     const compared = (source, target, into, seen) => {
         const key = `${String(source?.id)}>${String(target?.id)}`;
@@ -206,13 +254,24 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             }
             const element = elementOf(one);
             const called = element === undefined ? callOf(one) : undefined;
+            const sourceArguments = typeArgumentsOf(one);
             for (const part of targets) {
+                const partElement = elementOf(part);
+                if (element !== undefined && partElement !== undefined) {
+                    compared(element, partElement, into, seen);
+                    continue;
+                }
+                const targetArguments = typeArgumentsOf(part);
+                // A defaulted trailing parameter, as `Iterable<T, TReturn, TNext>` has, leaves
+                // the places two instantiations share comparable.
+                sourceArguments.slice(0, targetArguments.length).forEach((argument, index) => {
+                    compared(argument, targetArguments[index], into, seen);
+                });
                 if (element !== undefined) {
-                    compared(element, elementOf(part), into, seen);
                     continue;
                 }
                 const other = called === undefined ? undefined : callOf(part);
-                if (called === undefined || other === undefined) {
+                if (called === undefined || other?.kind !== called.kind) {
                     continue;
                 }
                 other.parameters.forEach((parameter, index) => {
@@ -239,7 +298,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             if (element !== undefined) {
                 return mayCarry(element, seen);
             }
-            return callOf(part) !== undefined;
+            return callOf(part) !== undefined || typeArgumentsOf(part).some((one) => mayCarry(one, seen));
         });
     };
     const sourced = carried.flatMap((flow, index) => {
@@ -288,5 +347,37 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             reads.push({ at: flow.value, from: flow.from, ids: [...ids] });
         }
     });
+    const copies = new Map();
+    /** Whether a spread copies the member: where any declaration of it declares data. */
+    const copied = (member) => {
+        let known = copies.get(member);
+        if (known === undefined) {
+            known = member.declarations.some((handle) => {
+                const node = project.declarationAt(handle)?.node;
+                return node === undefined || copiedBySpread(node);
+            });
+            copies.set(member, known);
+        }
+        return known;
+    };
+    const spreads = literals.flatMap(({ literal, from }) => literal.properties.flatMap((property) => isSpreadAssignment(property) ? [{ value: property.expression, from }] : []));
+    batches += batchesOf(spreads.length);
+    const spreadTypes = queries.typesAt(spreads.map((one) => one.value), cap);
+    spreads.forEach(({ value, from }, index) => {
+        const type = spreadTypes[index];
+        if (type === undefined || !isAnswered(type)) {
+            return;
+        }
+        // A spread gets every own enumerable property, an overwritten key's getter included,
+        // and no private name, which is no property
+        // (https://tc39.es/ecma262/#sec-copydataproperties).
+        const own = (member, id) => !privateNames.has(id) && copied(member);
+        const ids = [
+            ...new Set(partsOf(type).flatMap((part) => [...membersOf(part).values()].flatMap((member) => member.ids.filter((id) => own(member, id))))),
+        ];
+        if (ids.length > 0) {
+            reads.push({ at: value, from, ids });
+        }
+    });
     return { writes, reads, batches, lookups };
 }

package/dist/src/convention-rows.js

@@ -39,6 +39,12 @@ const BABEL_CONFIG = [
 const STRYKER_CONFIG = "{stryker,.stryker}.{conf,config}.{json,js,mjs,cjs}";
 const STRYKER_MODULE = "{stryker,.stryker}.{conf,config}.{js,mjs,cjs}";
 const VITEST_CONFIG = `{vitest,vite}.config.${ANY_MODULE}`;
+/**
+ * The properties Vitest takes its project root from, `test.root` before Vite's `root`; it
+ * resolves `setupFiles` and `globalSetup` against that root
+ * (https://vitest.dev/config/setupfiles, https://vitest.dev/config/globalsetup).
+ */
+const VITEST_ROOTS = ["test.root", "root"];
 /** The entry files of an Angular CLI project, at the workspace root or below `projects`. */
 const ANGULAR_ENTRIES = [
     "src/{main,main.server,server,polyfills,test}.ts",
@@ -535,5 +541,9 @@ export const CONVENTION_ROWS = [
             { property: "test.coverage.include", files: [VITEST_CONFIG] },
             { property: "test.coverage.exclude", files: [VITEST_CONFIG] },
         ],
+        testFiles: [
+            { property: "test.setupFiles", files: [VITEST_CONFIG], roots: VITEST_ROOTS },
+            { property: "test.globalSetup", files: [VITEST_CONFIG], roots: VITEST_ROOTS },
+        ],
     },
 ];

package/dist/src/conventions.js

@@ -413,6 +413,35 @@ function holdsValue(held, value) {
             return first !== undefined && literalText(first) === value;
         }));
 }
+/** The directory one file's test-file strings are read against, as {@link TestFileReading} states it. */
+function testFileRoot(file, dir, reading) {
+    for (const property of reading.roots) {
+        const values = valuesAt(file, property, reading.call);
+        if (values.length > 0) {
+            const texts = new Set(values.map(literalText));
+            const [text] = texts;
+            return texts.size === 1 && text !== undefined ? resolvePath(dir, text) : undefined;
+        }
+    }
+    return dir;
+}
+/** The files an applied row's test-file properties name. */
+function testFilesNamed(host, parse, dir, readings, into) {
+    for (const reading of readings) {
+        for (const { file } of readingFiles(host, parse, dir, reading.files)) {
+            const at = testFileRoot(file, dir, reading);
+            if (at === undefined) {
+                continue;
+            }
+            for (const node of stringsAt(file, reading.property, reading.call)) {
+                const text = literalText(node);
+                if (text !== undefined && text !== "") {
+                    into.add(resolvePath(at, text));
+                }
+            }
+        }
+    }
+}
 /** The strings an applied row's selection keys hold, added per configuration file to `into`. */
 function selectedStrings(host, parse, dir, readings, into) {
     for (const reading of readings) {
@@ -664,6 +693,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
     const failures = [];
     const uses = new Set();
     const selected = new Map();
+    const testFiles = new Set();
     for (const manifest of manifests) {
         const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
         const versions = new Map();
@@ -677,7 +707,9 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             }
             const version = versions.get(row.package);
             if (version === undefined) {
-                if (missing.has(row.package) || !declares(declared, row.package, REQUIRED_SECTIONS)) {
+                if (missing.has(row.package) ||
+                    manifest.nested === true ||
+                    !declares(declared, row.package, REQUIRED_SECTIONS)) {
                     continue;
                 }
                 missing.add(row.package);
@@ -735,6 +767,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
                 uses.add(name);
             }
             selectedStrings(host, parse, manifest.dir, row.selections ?? [], selected);
+            testFilesNamed(host, parse, manifest.dir, row.testFiles ?? [], testFiles);
             const excludes = [
                 ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
             ].map(globExpression);
@@ -762,6 +795,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
         failures,
         uses: [...uses].sort(compare),
         selected,
+        testFiles,
     };
 }
 /**