@cplieger/deadset-ts 2.3.0 → 3.0.0

package/dist/src/graph.js

@@ -0,0 +1,116 @@
+/**
+ * One project's declarations, the references between them and the roots that seed
+ * reachability, indexed for the sweep. The graph reads no file and asks the compiler
+ * nothing, so a sweep over it is a function of the values it was built from, and the
+ * inventory's order is the order every set a sweep answers reads in.
+ */
+/** The position of a declaration the inventory does not hold. */
+export const OUTSIDE = -1;
+/**
+ * Whether the sweep judges a declaration of each kind. A file is not judged by either
+ * relation: whether a file is built and whether anything imports it are the subjects of
+ * the file kinds, which read the program rather than ask whether anything references the
+ * file. The Contract's finding schema names the kinds that carry no liveness relation,
+ * and a test holds this table to that list.
+ */
+const SWEPT = {
+    file: false,
+    function: true,
+    class: true,
+    interface: true,
+    type: true,
+    enum: true,
+    namespace: true,
+    variable: true,
+    "export-alias": true,
+    method: true,
+    "class-member": true,
+    "interface-method": true,
+    "type-member": true,
+    "enum-member": true,
+    "type-parameter": true,
+};
+/**
+ * Whether a root of each kind names a caller, which holds it live under both relations: a
+ * tool reads the configuration it loads, a runtime runs a test file, a setup file and a
+ * worker, and a configured root asserts a caller. The other kinds only suppose a consumer
+ * that imports what a manifest entry, a binary or an entry file exports, or names a
+ * library's published API, so such a root is live under reachability alone.
+ */
+const NAMES_A_CALLER = {
+    "entry-file": false,
+    "manifest-entry": false,
+    "manifest-binary": false,
+    "published-api": false,
+    configured: true,
+    pattern: true,
+    "test-runner": true,
+    "lint-configuration": true,
+    "mutation-testing": true,
+    "browser-tests": true,
+    worker: true,
+};
+/** Whether the sweep judges a declaration of one kind. */
+export function swept(kind) {
+    return SWEPT[kind];
+}
+/** Whether a root of one kind names a caller rather than supposing one. */
+export function namesACaller(kind) {
+    return NAMES_A_CALLER[kind];
+}
+/**
+ * Indexes one project's inventory, references and roots. `testFiles` are the paths the
+ * reference pass classified as test files, so a declaration one holds is a test
+ * declaration. A reference to a declaration the inventory does not hold is dropped; one
+ * from such a declaration still counts toward its target, because reference counting
+ * asks whether any declaration names the target. A root naming nothing is dropped.
+ */
+export function graphOf(symbols, references, roots, testFiles) {
+    const index = new Map(symbols.map((symbol, at) => [symbol.id, at]));
+    const at = (id) => index.get(id) ?? OUTSIDE;
+    const tests = new Set(testFiles);
+    const out = symbols.map(() => []);
+    const made = symbols.map(() => ({ production: 0, test: 0 }));
+    for (const reference of references) {
+        const to = at(reference.to);
+        if (to === OUTSIDE) {
+            continue;
+        }
+        const counts = made[to];
+        if (counts !== undefined) {
+            if (reference.test) {
+                counts.test += 1;
+            }
+            else {
+                counts.production += 1;
+            }
+        }
+        out[at(reference.from)]?.push({ to, test: reference.test });
+    }
+    const parent = symbols.map((symbol) => at(symbol.parent));
+    const exportsOf = symbols.map(() => []);
+    symbols.forEach((symbol, position) => {
+        const container = parent[position] ?? OUTSIDE;
+        if (symbol.exported && symbols[container]?.kind === "file") {
+            exportsOf[container]?.push(position);
+        }
+    });
+    const rooted = [];
+    for (const root of roots) {
+        const position = at(root.id);
+        if (position !== OUTSIDE) {
+            rooted.push({ at: position, kind: root.kind });
+        }
+    }
+    return {
+        symbols,
+        out,
+        made,
+        parent,
+        test: symbols.map((symbol) => tests.has(symbol.position.path)),
+        subject: symbols.map((symbol) => swept(symbol.kind)),
+        exportsOf,
+        rooted,
+        at,
+    };
+}

package/dist/src/index.js

@@ -1,7 +1,5 @@
 export { run, SETTING_OPTIONS } from "./run.js";
 export { DECLINED_CONVENTIONS } from "./entry-point-gaps.js";
-export { inventory, nodeKey, } from "./inventory.js";
-export { DEFAULT_BATCH_CAP, references, } from "./references.js";
 export { byPosition, positionKey, PositionError, renderPosition, } from "./position.js";
 export { computedComponent, isRef, nameComponent, REF_EXPRESSIONS, renderRef, } from "./ref.js";
 export { CONTRACT_VERSION } from "./version.js";

package/dist/src/print.js

@@ -19,12 +19,9 @@ export function printConfig(config, provenance) {
             min_confidence: config.analysis.minConfidence,
             generated_files: config.analysis.generatedFiles,
             consumer_tests: config.analysis.consumerTests,
-            configurations: config.analysis.configurations.map((entry) => ({
-                id: entry.id,
-                os: entry.os,
-                arch: entry.arch,
-                tags: entry.tags,
-            })),
+            configurations: config.analysis.configurations.map((entry) => entry.shape === "project"
+                ? { id: entry.id, project: entry.project }
+                : { id: entry.id, os: entry.os, arch: entry.arch, tags: entry.tags }),
             matrix: { complete: config.analysis.matrixComplete },
             template_dirs: config.analysis.templateDirs,
             template_delimiters: {

package/dist/src/references.js

@@ -1,4 +1,4 @@
-import { isArrayLiteralExpression, isBinaryExpression, isDeleteExpression, isElementAccessExpression, isForInStatement, isForOfStatement, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrayLiteralExpression, isBinaryExpression, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isForInStatement, isForOfStatement, isNamespaceExport, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
@@ -126,18 +126,54 @@ function markStores(node, writes) {
         }
     }
 }
+/**
+ * The re-exports one node writes, if it is an export declaration. A specifier and a
+ * namespace export are declarations whose names are where they are written, so no use is
+ * read from them; each references what it carries forward instead. A bare star declares
+ * nothing, so the declaration enclosing it, at the top level the file, references the
+ * module it names.
+ */
+function linksOf(file, node, declarations, enclosing) {
+    if (!isExportDeclaration(node)) {
+        return [];
+    }
+    const clause = node.exportClause;
+    const specifier = node.moduleSpecifier;
+    if (clause === undefined) {
+        return specifier === undefined
+            ? []
+            : [{ node: specifier, at: specifier, from: enclosing, alias: false }];
+    }
+    if (isNamespaceExport(clause)) {
+        const from = declarations.get(nodeKey(file, clause));
+        return from === undefined
+            ? []
+            : [{ node: clause.name, at: specifier ?? clause.name, from, alias: true }];
+    }
+    const found = [];
+    for (const element of clause.elements) {
+        const from = declarations.get(nodeKey(file, element));
+        if (from !== undefined) {
+            found.push({
+                node: element.name,
+                at: element.propertyName ?? element.name,
+                from,
+                alias: true,
+            });
+        }
+    }
+    return found;
+}
 /**
  * Every name node one file holds that is a use rather than a declaration, in source
- * order, each with the declaration that encloses it and the use it makes.
- *
- * One walk answers all three, because the three facts are positional and a second walk
- * would have to agree with this one about which nodes are names. A name that is the
- * declared name of the declaration it belongs to is left out: it is where that
- * declaration is written rather than a use of it, which is what makes a declaration
- * referenced only from its own site an unreferenced declaration.
+ * order, each with its enclosing declaration and its use, and every re-export the file
+ * writes. One walk answers all of it, because a second would have to agree with this one
+ * about which nodes are names. A declaration's own declared name is left out, which is
+ * what makes a declaration referenced only from its own site an unreferenced one.
  */
 function sitesOf(file, declarations, fileId) {
     const found = [];
+    const links = [];
     const writes = new Set();
     const declared = new Set();
     const shorthands = new Map();
@@ -173,6 +209,7 @@ function sitesOf(file, declarations, fileId) {
         }
         markNames(node);
         markStores(node, writes);
+        links.push(...linksOf(file, node, declarations, enclosing));
         const held = declarations.get(nodeKey(file, node));
         const outer = enclosing;
         if (held !== undefined) {
@@ -182,7 +219,7 @@ function sitesOf(file, declarations, fileId) {
         enclosing = outer;
     };
     file.forEachChild(visit);
-    return found;
+    return { uses: found, links };
 }
 /**
  * The name one test-file rule takes. A rule's name is a word list the report's own
@@ -218,7 +255,9 @@ export function references(project, held, targetRoot, options) {
     const patterns = options.testFiles.map(globExpression);
     const matched = options.testFiles.map(() => 0);
     const found = [];
+    const tests = [];
     const reached = new Map();
+    const steps = new Map();
     let batched = 0;
     let fileBatches = 0;
     let residueFallbacks = 0;
@@ -228,23 +267,51 @@ export function references(project, held, targetRoot, options) {
     const ownFiles = new Set(files.map((file) => file.fileName));
     /** The identifier of the declaration one node of this program is, where it is one. */
     const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
+    /**
+     * The declarations of the inventory one symbol is.
+     *
+     * A declaration handle carries the file it is in, so the question is answered before
+     * the handle is resolved: a declaration outside the project's own files belongs to
+     * another program and is never read, which is what keeps the pass from fetching a
+     * library file to discover that the inventory does not hold what is in it.
+     */
+    const declarationsOf = (symbol) => {
+        const ids = [];
+        for (const handle of symbol.declarations) {
+            if (!ownFiles.has(handle.path)) {
+                continue;
+            }
+            const node = project.declarationAt(handle)?.node;
+            const id = node === undefined ? undefined : declaredAt(node);
+            if (id !== undefined && !ids.includes(id)) {
+                ids.push(id);
+            }
+        }
+        return ids;
+    };
+    /**
+     * What one alias names, one link along, asked once per alias whatever the number of
+     * chains it is a link of. Only a symbol the binder flagged an alias is asked, which is
+     * the condition the step asserts on: a default export of an expression is written in
+     * an alias form and names nothing declared elsewhere, so its chain ends at itself.
+     */
+    const stepOf = (symbol) => {
+        if ((symbol.flags & SymbolFlags.Alias) === 0) {
+            return undefined;
+        }
+        if (steps.has(symbol.id)) {
+            return steps.get(symbol.id);
+        }
+        const next = project.aliasStepOf(symbol);
+        aliasSteps += 1;
+        steps.set(symbol.id, next);
+        return next;
+    };
     /**
      * The declarations one symbol names: the declaration it is, and every link of the
      * alias chain it stands at the head of. A re-export something imports is used and so
      * is the declaration behind it, so both are named; a link this project does not
      * declare is stepped over rather than recorded.
-     *
-     * A symbol is asked to step only where the binder flagged it an alias, which is the
-     * same condition the step itself asserts on. The declaration's syntax is not that
-     * condition and does not stand in for it: a default export of an expression is
-     * written as one of the alias forms and names nothing declared elsewhere, so it is
-     * recorded as the declaration it is and the chain ends there.
-     *
-     * A declaration handle carries the file it is in, so the question the walk asks of a
-     * declaration is answered before it is resolved: a declaration outside the project's
-     * own files belongs to another program and is never read, which is what keeps the
-     * pass from fetching a library file to discover that the inventory does not hold what
-     * is in it.
      */
     const targetsOf = (symbol) => {
         const cached = reached.get(symbol.id);
@@ -257,34 +324,47 @@ export function references(project, held, targetRoot, options) {
         let stepped = false;
         while (at !== undefined && !walked.has(at.id)) {
             walked.add(at.id);
-            const alias = (at.flags & SymbolFlags.Alias) !== 0;
-            for (const handle of at.declarations) {
-                if (!ownFiles.has(handle.path)) {
-                    continue;
-                }
-                const node = project.declarationAt(handle)?.node;
-                const id = node === undefined ? undefined : declaredAt(node);
-                if (id !== undefined && !targets.some((target) => target.id === id)) {
+            for (const id of declarationsOf(at)) {
+                if (!targets.some((target) => target.id === id)) {
                     targets.push({ id, stepped });
                 }
             }
-            if (!alias) {
-                break;
-            }
-            at = project.aliasStepOf(at);
-            aliasSteps += 1;
+            at = stepOf(at);
             stepped = true;
         }
         reached.set(symbol.id, targets);
         return targets;
     };
+    /**
+     * The declarations one re-export carries forward: for an alias, the first link along
+     * its chain that the inventory declares, stepping over the links it does not, such as
+     * an import the re-export is written against; for a bare star, the module it names.
+     * Each later link is a declaration of its own that references the next, so one link
+     * per re-export is what lets a chain be followed one declaration at a time.
+     */
+    const carriedBy = (link, symbol) => {
+        if (!link.alias) {
+            return declarationsOf(symbol);
+        }
+        const walked = new Set([symbol.id]);
+        let at = stepOf(symbol);
+        while (at !== undefined && !walked.has(at.id)) {
+            walked.add(at.id);
+            const ids = declarationsOf(at);
+            if (ids.length > 0) {
+                return ids;
+            }
+            at = stepOf(at);
+        }
+        return [];
+    };
     /** The symbol one site resolves to, asking only the accessor the site's form names. */
     const symbolFor = (site, answered) => {
         if (site.shorthand !== undefined) {
             shorthandLookups += 1;
             return project.shorthandValueAt(project.handle(site.shorthand));
         }
-        const batched = answered.get(site.node.pos);
+        const batched = answered.get(site.node);
         if (batched !== undefined) {
             return batched;
         }
@@ -293,35 +373,59 @@ export function references(project, held, targetRoot, options) {
     };
     for (const file of files) {
         const path = renderPosition(file, targetRoot, 0).path;
-        let test = false;
-        patterns.forEach((pattern, index) => {
-            if (pattern.test(path)) {
+        const hits = patterns.map((pattern) => pattern.test(path));
+        hits.forEach((hit, index) => {
+            if (hit) {
                 matched[index] = (matched[index] ?? 0) + 1;
-                test = true;
             }
         });
-        const sites = sitesOf(file, declarations, declaredAt(file) ?? "");
-        // One batch per capped run of the file's name nodes. A shorthand is left out of
-        // the batch: its name resolves to the property the literal declares, so the batch's
-        // answer for it would name something this project's inventory never holds.
-        const batching = sites.filter((site) => site.shorthand === undefined);
+        const test = hits.includes(true);
+        if (test) {
+            tests.push(path);
+        }
+        const { uses, links } = sitesOf(file, declarations, declaredAt(file) ?? "");
+        // One batch per capped run of the file's name nodes, the re-exports' nodes after
+        // the uses. A shorthand is left out of the batch: its name resolves to the property
+        // the literal declares, so the batch's answer for it would name something this
+        // project's inventory never holds.
+        const batching = [
+            ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
+            ...links.map((link) => link.node),
+        ];
         const answered = new Map();
         batched += batching.length;
         for (let from = 0; from < batching.length; from += cap) {
             const run = batching.slice(from, from + cap);
-            const answers = project.symbolsAt(run.map((site) => project.handle(site.node)));
+            const answers = project.symbolsAt(run.map((node) => project.handle(node)));
             fileBatches += 1;
-            run.forEach((site, index) => {
+            run.forEach((node, index) => {
                 const symbol = answers[index];
                 if (symbol !== undefined) {
-                    answered.set(site.node.pos, symbol);
+                    answered.set(node, symbol);
                 }
             });
         }
-        for (const site of sites) {
+        for (const link of links) {
+            const symbol = answered.get(link.node);
+            if (symbol === undefined) {
+                continue;
+            }
+            const position = renderPosition(file, targetRoot, link.at.getStart());
+            for (const id of carriedBy(link, symbol)) {
+                found.push({
+                    from: link.from,
+                    to: id,
+                    position,
+                    use: "read",
+                    resolution: link.alias ? "alias" : "batch",
+                    test,
+                });
+            }
+        }
+        for (const site of uses) {
             const direct = site.shorthand !== undefined
                 ? "shorthand"
-                : answered.has(site.node.pos)
+                : answered.has(site.node)
                     ? "batch"
                     : "resolved-symbol";
             const symbol = symbolFor(site, answered);
@@ -351,6 +455,7 @@ export function references(project, held, targetRoot, options) {
         testFileRules: options.testFiles
             .map((_pattern, index) => ({ rule: patternRule(index), matched: matched[index] ?? 0 }))
             .sort((a, b) => compare(a.rule, b.rule)),
+        testFilePaths: tests.sort(compare),
         cost: { batched, fileBatches, residueFallbacks, shorthandLookups, aliasSteps },
     };
 }

package/dist/src/resolve.js

@@ -8,6 +8,20 @@ const FAMILY_KEY_LENGTH = 4;
 const SEVERITY_KEY = /^DS[0-9]{2}([0-9]{2})?$/u;
 const EXEMPTION_CLASS = /^[a-z][a-z0-9-]*$/u;
 const CONTRACT_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+$/u;
+/** The members only a platform build configuration carries. */
+const PLATFORM_MEMBERS = ["os", "arch", "tags"];
+/** The member only a project build configuration carries. */
+const PROJECT_MEMBER = "project";
+/**
+ * One segment of a project path: not empty, not `.` or `..`, and holding no
+ * solidus, backslash or line break.
+ */
+const PROJECT_SEGMENT = String.raw `(?:[^/\\.\r\n][^/\\\r\n]*|\.[^/\\.\r\n][^/\\\r\n]*|\.\.[^/\\\r\n]+)`;
+/**
+ * A project path: segments joined by a solidus, so the path is relative, below
+ * the root it is read against, and spelled one way on every machine.
+ */
+const PROJECT_PATH = new RegExp(`^${PROJECT_SEGMENT}(?:/${PROJECT_SEGMENT})*$`, "u");
 const TARGET_KINDS = ["application", "library"];
 const CONFIDENCES = ["certain", "probable", "possible"];
 const GENERATED_FILES = ["exclude", "include"];
@@ -135,10 +149,52 @@ function requireMember(value, path, label) {
     }
     return value;
 }
+/** One build configuration entry as a platform: an identifier, an operating system and an architecture. */
+function readPlatform(entry, at, label) {
+    return {
+        shape: "platform",
+        id: requireMember(readString(entry, "id", `${at}.id`, label), `${at}.id`, label),
+        os: requireMember(readString(entry, "os", `${at}.os`, label), `${at}.os`, label),
+        arch: requireMember(readString(entry, "arch", `${at}.arch`, label), `${at}.arch`, label),
+        tags: readStrings(entry, "tags", `${at}.tags`, label, 0) ?? [],
+    };
+}
+/** One build configuration entry as a project: an identifier and a configuration file below the target root. */
+function readProject(entry, at, label) {
+    const id = requireMember(readString(entry, "id", `${at}.id`, label), `${at}.id`, label);
+    const path = `${at}.${PROJECT_MEMBER}`;
+    const project = requireMember(readString(entry, PROJECT_MEMBER, path, label), path, label);
+    if (!PROJECT_PATH.test(project)) {
+        throw malformed(label, path, `${JSON.stringify(project)} is not a path below the target root: segments joined by /, ` +
+            "none empty, . or .., and no backslash or line break");
+    }
+    return { shape: "project", id, project };
+}
 /**
- * The build matrix: every entry names an identifier, an operating system and an
- * architecture.
+ * One build configuration entry, read as the one shape its members name: a member
+ * only a platform carries makes it a platform, the member only a project carries
+ * makes it a project, and an entry naming members of both, or of neither, is
+ * refused at the entry, because the two shapes are exclusive.
  */
+function readConfiguration(entry, at, label) {
+    if (!isRecord(entry)) {
+        throw malformed(label, at, "is not an object");
+    }
+    const platform = PLATFORM_MEMBERS.filter((name) => Object.hasOwn(entry, name));
+    const project = Object.hasOwn(entry, PROJECT_MEMBER);
+    if (platform.length > 0 && project) {
+        throw malformed(label, at, `carries ${spell(platform)} of a platform and ${JSON.stringify(PROJECT_MEMBER)} of a ` +
+            "project, and an entry is one shape or the other");
+    }
+    if (project) {
+        return readProject(entry, at, label);
+    }
+    if (platform.length === 0) {
+        throw malformed(label, at, `names neither a platform's "os" and "arch" nor a project's ${JSON.stringify(PROJECT_MEMBER)}`);
+    }
+    return readPlatform(entry, at, label);
+}
+/** The build matrix, one entry in one shape at a time. */
 function readConfigurations(analysis, label) {
     const value = member(analysis, "configurations");
     if (value === undefined) {
@@ -147,18 +203,7 @@ function readConfigurations(analysis, label) {
     if (!Array.isArray(value)) {
         throw malformed(label, "analysis.configurations", "is not an array");
     }
-    return value.map((entry, index) => {
-        const at = `analysis.configurations[${String(index)}]`;
-        if (!isRecord(entry)) {
-            throw malformed(label, at, "is not an object");
-        }
-        return {
-            id: requireMember(readString(entry, "id", `${at}.id`, label), `${at}.id`, label),
-            os: requireMember(readString(entry, "os", `${at}.os`, label), `${at}.os`, label),
-            arch: requireMember(readString(entry, "arch", `${at}.arch`, label), `${at}.arch`, label),
-            tags: readStrings(entry, "tags", `${at}.tags`, label, 0) ?? [],
-        };
-    });
+    return value.map((entry, index) => readConfiguration(entry, `analysis.configurations[${String(index)}]`, label));
 }
 /**
  * The action delimiter pair: once a document names the object both members are
@@ -439,6 +484,29 @@ function checkLabels(provenance) {
  * the usage exit code.
  */
 export function resolve(inputs) {
+    const { config, provenance } = settleAll(inputs);
+    if (config.targetKind === "") {
+        throw new ConfigError("missing-target-kind", "target.kind", "target.kind is not set, it has no default and is never inferred: searched " +
+            `${describeSource("the repository configuration", inputs.repository, inputs.repositoryLabel)} and ` +
+            describeSource("the central configuration", inputs.central, inputs.centralLabel));
+    }
+    checkLabels(provenance);
+    return { config, provenance };
+}
+/**
+ * The build matrix the configuration documents resolve to, every document read and
+ * refused as {@link resolve} refuses it, and nothing else required of them: which
+ * projects a run analyzes depends on the matrix alone, so a question about the
+ * projects asks no target kind.
+ */
+export function resolveMatrix(inputs) {
+    return settleAll(inputs).config.analysis.configurations;
+}
+/**
+ * Every setting the documents supply, each from the highest-ranked source carrying
+ * it, with the origin of each. The target kind is empty where no source names one.
+ */
+function settleAll(inputs) {
     const sources = readSources(inputs);
     const defaults = defaultConfig();
     const provenance = new Map();
@@ -472,11 +540,5 @@ export function resolve(inputs) {
             entryFiles: at("ts.entry_files", defaults.ts.entryFiles, (doc) => doc.entryFiles),
         },
     };
-    if (config.targetKind === "") {
-        throw new ConfigError("missing-target-kind", "target.kind", "target.kind is not set, it has no default and is never inferred: searched " +
-            `${describeSource("the repository configuration", inputs.repository, inputs.repositoryLabel)} and ` +
-            describeSource("the central configuration", inputs.central, inputs.centralLabel));
-    }
-    checkLabels(provenance);
     return { config, provenance };
 }

package/dist/src/run.js

@@ -3,7 +3,7 @@ import { ConfigError, REPOSITORY_DOCUMENT } from "./config.js";
 import { diagnosticErrors, discoverProjects, DiscoveryError, renderDiagnostic, } from "./discover.js";
 import { joinPath, resolvePath } from "./paths.js";
 import { printConfig } from "./print.js";
-import { resolve } from "./resolve.js";
+import { resolve, resolveMatrix } from "./resolve.js";
 import { readScope, ScopeError, scopeForDir } from "./scope.js";
 import { diagnosticsOf, openEngine, runSession } from "./session.js";
 import { CONTRACT_VERSION } from "./version.js";
@@ -197,21 +197,25 @@ function printConfigVerb(args, out, err, host) {
     }
 }
 /**
- * Writes the compiler configuration of every project one run analyzes, one per
- * line, in discovery order, having read each project's diagnostics first.
+ * Writes the name of every project one run analyzes, one per line, having read each
+ * project's diagnostics first: the identifier the build matrix declares for it, or,
+ * where discovery derived the project, its configuration file's path below the
+ * target root.
  */
 function printProjectsVerb(args, out, err, host, openClient) {
     let engine;
     try {
         const options = readOptions(args);
+        const matrix = resolveMatrix(inputsOf(host, options));
         const scope = scopeOf(host, options);
         engine = openClient(false);
-        const discovered = discoverProjects(engine, host, scope);
+        const discovered = discoverProjects(engine, host, scope, matrix);
+        const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
         const failures = [];
         const { projects } = runSession(engine, discovered.configFiles, (project) => {
             const errors = diagnosticErrors(diagnosticsOf(project));
             failures.push(...errors.map(renderDiagnostic));
-            return project.configFile;
+            return ids.get(project.configFile) ?? project.configFile;
         });
         if (failures.length > 0) {
             for (const line of failures) {
@@ -220,8 +224,8 @@ function printProjectsVerb(args, out, err, host, openClient) {
             err.write(`deadset-ts: ${String(failures.length)} error(s); no answer was produced\n`);
             return EXIT_FAILURE;
         }
-        for (const configFile of projects) {
-            out.write(`${configFile}\n`);
+        for (const id of projects) {
+            out.write(`${id}\n`);
         }
         return EXIT_CLEAN;
     }

package/dist/src/schema.js

@@ -19,7 +19,7 @@ export const SCHEMA_ROOT = {
                 consumer_tests: leaf,
                 configurations: {
                     kind: "list",
-                    members: { id: leaf, os: leaf, arch: leaf, tags: leaf },
+                    members: { id: leaf, os: leaf, arch: leaf, tags: leaf, project: leaf },
                 },
                 matrix: { kind: "section", members: { complete: leaf } },
                 template_dirs: leaf,