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

package/dist/src/analysis.js

@@ -23,7 +23,7 @@ import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhi
 import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
 import { globExpression } from "./glob.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
-import { NO_SELF_CHECK, unmatchedRootFindings, } from "./findings/self-check.js";
+import { unmatchedRootFindings } from "./findings/self-check.js";
 import { frameworkLifecycle } from "./framework-lifecycle.js";
 import { implementations, mergeImplementations } from "./implementations.js";
 import { injectionContainer } from "./injection-container.js";
@@ -243,6 +243,7 @@ function readProjects(engine, host, scope, config, stage) {
                     .filter((file) => referenceOnly(file.fileName))
                     .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
                 generated: generatedFilesOf(own, generatedFiles(conventions, own)),
+                testFileNames: conventions.testFiles,
             };
         };
         for (const file of project.ownSourceFiles()) {
@@ -346,7 +347,7 @@ export function runRoots(engine, host, scope, config, provenance) {
     };
 }
 /** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
-const DETECTORS = new Map([
+export const DETECTORS = new Map([
     ["interface-satisfaction", interfaceSatisfaction],
     ["enum-group", enumGroup],
     ["generated-file", generatedFile],
@@ -374,6 +375,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         const projectRead = opened.read();
         const resolved = references(project, projectRead.held, targetRoot, {
             testFiles: config.ts.testFiles,
+            testFileNames: projectRead.testFileNames,
         });
         const evidence = evidenceRecords({
             project,
@@ -419,7 +421,6 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         const { projectRead } = one;
         const satisfied = settled[index];
         const detected = heldRecords(satisfied?.evidence ?? one.evidence, {
-            disabled,
             mode,
             testFiles: new Set([...one.testFiles, ...support]),
         });
@@ -623,7 +624,7 @@ export function runSweep(engine, host, scope, config, input, detectors = DETECTO
     return sweptOf(readRun(engine, host, scope, config, input.mode, detectors, () => undefined), input);
 }
 /** Reads a run's projects with every per-project fact an emitter reads. */
-function readEmitterRun(engine, host, scope, config, mode, detectors) {
+export function readEmitterRun(engine, host, scope, config, mode, detectors) {
     const targetRoot = scope.target.path;
     const run = readRun(engine, host, scope, config, mode, detectors, (project, read, references) => ({
         deprecation: deprecatedDeclarations(project, read.held),
@@ -682,7 +683,7 @@ function nearestManifestDir(host, root, file) {
  * The input every emitter reads over one sweep of a read run: the facts beside the sweep
  * each kind family reads, every per-project one read in the same session as the sweep.
  */
-function emitterInputOver(host, scope, config, read, input, selfCheck) {
+export function emitterInputOver(host, scope, config, read, input, selfCheck) {
     const targetRoot = scope.target.path;
     const swept = sweptOf(read, input);
     const { projects } = read;
@@ -714,17 +715,6 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
         intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...swept.exempt.map((one) => one.id), ...swept.heldByUnanswered])),
     };
 }
-/**
- * What every emitter reads of the run the scope and the configuration describe, swept
- * under the caller's marks: the run's sweep, the facts beside it each kind family reads,
- * and the sides of the target's declared cross-language edges that name a symbol of this
- * language. The run reads no suppression document, so the self-check family has nothing
- * to report.
- */
-export function runEmitterInput(engine, host, scope, config, input, detectors = DETECTORS) {
-    const read = readEmitterRun(engine, host, scope, config, input.mode, detectors);
-    return emitterInputOver(host, scope, config, read, input, NO_SELF_CHECK);
-}
 /**
  * Reads the run the scope and the configuration describe for its findings. The inline
  * directives, the ignore file's entries and the baseline's rows are bound before any

package/dist/src/component-layer.js

@@ -7,7 +7,7 @@
  */
 import { dirnamePath, joinPath } from "./paths.js";
 /** The name the mapper's manifest declares and every configuration's entry names. */
-export const MAPPER_PACKAGE = "deadset-ts-component-files";
+const MAPPER_PACKAGE = "deadset-ts-component-files";
 /** The manifest of the mapper's package, which runs `command`. */
 export function mapperManifest(command) {
     return `${JSON.stringify({

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, [...dirs], files, holdsManifest, parse, named),
     };
 }
 /** The relative specifiers one file's imports and re-exports name. */
@@ -195,8 +389,8 @@ export function resolveRelativeSpecifier(host, dir, specifier) {
  * 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.
  */
-function outsideModules(host, dirs, files, holdsManifest, parse) {
-    const pending = [];
+function outsideModules(host, 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) {
                 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/contextual-uses.js

@@ -3,11 +3,11 @@
  * 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 { SignatureKind } from "@typescript/native/unstable/sync";
+import { isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { SignatureKind, SymbolFlags } 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. */
 const MEMBER_KINDS = new Set(["type-member", "class-member"]);
@@ -45,6 +45,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);
@@ -84,6 +87,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                     .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)),
+                accessor: (property.flags & SymbolFlags.Accessor) !== 0,
             });
         }
         tables.set(type.id, table);
@@ -158,13 +162,22 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         return element;
     };
     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 +185,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,
             };
@@ -212,7 +226,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                     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) => {
@@ -288,5 +302,25 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             reads.push({ at: flow.value, from: flow.from, ids: [...ids] });
         }
     });
+    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.
+        // So it reads each data member but a class's accessor, which sits on the prototype with
+        // the class's methods (never data members), and a private name, which is no property
+        // (https://tc39.es/ecma262/#sec-copydataproperties).
+        const own = (member, id) => !privateNames.has(id) && !(member.accessor && kinds.get(id) === "class-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,11 @@ 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` against that root (https://vitest.dev/config/setupfiles).
+ */
+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 +540,6 @@ 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 }],
     },
 ];

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();
@@ -735,6 +765,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 +793,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
         failures,
         uses: [...uses].sort(compare),
         selected,
+        testFiles,
     };
 }
 /**

package/dist/src/dependencies.js

@@ -244,16 +244,20 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
             use(ownersOf(file, held, node), dependenciesNamed(text, names));
         }
     }
-    for (const document of configuration.documents) {
-        const names = declaredAt(document.path);
-        for (const text of document.strings) {
-            use([PROJECT_OWNER], dependenciesNamed(text, names));
+    for (const { strings, manifestDirs } of configuration.documents) {
+        for (const manifestDir of manifestDirs) {
+            const names = declaredAt(joinPath(manifestDir, "package.json"));
+            for (const text of strings) {
+                use([PROJECT_OWNER], dependenciesNamed(text, names));
+            }
         }
     }
-    for (const { file, manifestDir } of configuration.outside) {
-        const names = declaredAt(joinPath(manifestDir, "package.json"));
-        for (const { text } of moduleStrings(file)) {
-            use([PROJECT_OWNER], dependenciesNamed(text, names));
+    for (const { file, manifestDirs } of configuration.outside) {
+        for (const manifestDir of manifestDirs) {
+            const names = declaredAt(joinPath(manifestDir, "package.json"));
+            for (const { text } of moduleStrings(file)) {
+                use([PROJECT_OWNER], dependenciesNamed(text, names));
+            }
         }
     }
     return { packages, uses, unanswered };

package/dist/src/discover.js

@@ -23,7 +23,7 @@ export class DiscoveryError extends Error {
 /** The category an error diagnostic carries, which the protocol sends as a number. */
 const ERROR_CATEGORY = DiagnosticCategory.Error;
 /** Whether one diagnostic is an error, which is what fails a run closed. */
-export function isError(diagnostic) {
+function isError(diagnostic) {
     return diagnostic.category === ERROR_CATEGORY;
 }
 /**

package/dist/src/edges.js

@@ -25,7 +25,7 @@ const EDGE_WANT = "an edge naming id, provides and used_by, each a string, and a
 const ID_WANT = "one or more solidus-separated segments of ASCII letters, digits, underscore, full stop and hyphen";
 const REFERENCE_WANT = "a stable symbol reference naming one symbol exactly, <language>://<scope>#<fragment>";
 /** An edges document the Contract refuses: a malformed input, answered with the usage code. */
-export class EdgesError extends ConfigError {
+class EdgesError extends ConfigError {
     constructor(at, text, want) {
         super("malformed", EDGES_FILE, `${at}: ${text}: want ${want}`);
         this.name = "EdgesError";