@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.11

package/dist/src/session.js

@@ -1,8 +1,18 @@
 import { API, SymbolFlags } from "@typescript/native/sync";
 import { componentLayer, mapperManifest } from "./component-layer.js";
-import { DiscoveryError } from "./discover.js";
 import { joinPath } from "./paths.js";
 import { queriesOf, UnansweredLog, } from "./query.js";
+import { MANIFEST } from "./fs/manifest.js";
+/** The most questions one round trip carries. */
+const BATCH = 2048;
+/** Asks one question of every item, in round trips of at most {@link BATCH}, answers in order. */
+export function batched(engine, items, question) {
+    const answers = [];
+    for (let at = 0; at < items.length; at += BATCH) {
+        answers.push(...engine.batch(items.slice(at, at + BATCH).map(question)));
+    }
+    return answers;
+}
 /**
  * Opens the compiler client the analysis reads through.
  *
@@ -16,7 +26,7 @@ export function openEngine(options) {
     if (components !== undefined && components.extensions.length > 0) {
         const made = components.host.temporaryDirectory();
         try {
-            components.host.writeDocument(joinPath(made.path, "package.json"), [
+            components.host.writeDocument(joinPath(made.path, MANIFEST), [
                 mapperManifest(components.host.componentMapperCommand()),
             ]);
         }
@@ -252,14 +262,13 @@ function projectsOf(snapshot, built, written) {
     return opened;
 }
 /**
- * Runs `visit` over every project the compiler configurations name, inside one never updated
- * snapshot of one client, and answers in their order. A configuration `programs` describes is
- * built as that program, or opened from the configuration it writes. One the snapshot holds
- * nothing for ends the run under `"refuse"` and is named in the result under `"record"`.
- * `first` runs over every opened project before the first visit and `last` after the last,
- * both while the client answers; the snapshot and the client are then released.
+ * Opens every project the compiler configurations name in one never updated snapshot of one
+ * client, and hands them to `use` while the client answers; the snapshot and the client are
+ * then released. A configuration `options.programs` describes is built as that program, or
+ * opened from the configuration it writes. One the snapshot holds nothing for has no view.
  */
-export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map(), last = () => undefined, first = () => undefined) {
+export function openSession(engine, configFiles, options, use) {
+    const programs = options.programs ?? new Map();
     try {
         const built = [];
         const params = [];
@@ -281,30 +290,13 @@ export function runSession(engine, configFiles, visit, unopened = "refuse", prog
             const opened = projectsOf(snapshot, built, written);
             const log = new UnansweredLog();
             const views = [];
-            const missing = [];
             for (const configFile of configFiles) {
                 const project = opened.get(configFile);
-                if (project === undefined) {
-                    if (unopened === "refuse") {
-                        throw new DiscoveryError(`${configFile} opened no project`, []);
-                    }
-                    missing.push(configFile);
-                    continue;
+                if (project !== undefined) {
+                    views.push(viewOf(project, configFile, engine, log));
                 }
-                views.push(viewOf(project, configFile, engine, log));
             }
-            first(views.map((view) => ({
-                configFile: view.configFile,
-                fileNames: () => view.ownSourceFiles().map((file) => file.fileName),
-            })));
-            const projects = views.map((view) => visit(view));
-            last();
-            return {
-                projects,
-                unopened: missing,
-                timing: engine.getTimingInfo(),
-                unanswered: log.questions,
-            };
+            return use({ views }, () => log.questions);
         }
         finally {
             snapshot.dispose();
@@ -314,3 +306,16 @@ export function runSession(engine, configFiles, visit, unopened = "refuse", prog
         engine.close();
     }
 }
+/**
+ * Runs `visit` over the project {@link openSession} opens for each configuration, and answers
+ * in their order; a configuration the snapshot opens nothing for throws before any visit.
+ */
+export function runSession(engine, configFiles, visit) {
+    return openSession(engine, configFiles, {}, (opened) => {
+        const unopened = configFiles.find((configFile) => !opened.views.some((view) => view.configFile === configFile));
+        if (unopened !== undefined) {
+            throw new Error(`${unopened} opened no project`);
+        }
+        return { projects: opened.views.map((view) => visit(view)), timing: engine.getTimingInfo() };
+    });
+}

package/dist/src/source-files.js

@@ -3,7 +3,7 @@
  * in a document or a string names one: as the file itself, or as a file the
  * compiler emits from it.
  */
-import { commonDirectory, emittedFrom } from "./emit-map.js";
+import { commonDirectory, emittedFrom } from "./load/emit-map.js";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";

package/dist/src/suppress-file.js

@@ -4,11 +4,13 @@
  * one record shape, so one decoder and one matcher serve both, and a row moves into the
  * ignore file by gaining a maintainer's reason.
  */
+import { CODE } from "./contract/contract.generated.js";
+import { readTargetDocument } from "./fs/document.js";
 import { jsonChunks } from "./json-chunks.js";
-import { joinPath } from "./paths.js";
-import { positionAt, walkDocument } from "./json-document.js";
+import { isRecord, positionAt, readStrict, StrictJSONError } from "./json-document.js";
 import { declarationKey } from "./ref.js";
-import { CODE_FORM, SUPPRESSION_WITHOUT_REASON, SuppressionError, UNSCOPED_ENTRY, blankReason, isEntryPath, isPartKind, isSymbolRef, siteText, } from "./suppress.js";
+import { CODE_FORM, SuppressionError, blankReason, isEntryPath, isPartKind, isSymbolRef, siteText, } from "./suppress.js";
+import { message } from "./product.js";
 /** The name and the location the grammar fixes for the ignore file. */
 export const IGNORE_FILE = "deadset-ignore.json";
 /** The name and the location the grammar fixes for the baseline. */
@@ -42,9 +44,6 @@ const PATH_WANT = "a path relative to the target root, with the solidus as separ
 function documentSite(shape) {
     return { path: shape.file, line: 0, column: 0 };
 }
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 /**
  * Reads one entry or row: the records it binds, the refusals it carries, or the
  * malformed value that ends the run.
@@ -53,7 +52,7 @@ function readRecord(value, site, byReference, shape) {
     const refuse = (text, want) => {
         throw new SuppressionError(shape.mechanism, siteText(site), text, want);
     };
-    if (!isObject(value)) {
+    if (!isRecord(value)) {
         return refuse(JSON.stringify(value), shape.recordWant);
     }
     for (const [key, held] of Object.entries(value)) {
@@ -99,10 +98,10 @@ function readRecord(value, site, byReference, shape) {
     };
     const refusals = [];
     if (blankReason(reason)) {
-        refusals.push({ ...written, reported: SUPPRESSION_WITHOUT_REASON });
+        refusals.push({ ...written, reported: CODE.suppressionWithoutReason });
     }
     if (written.path === "") {
-        refusals.push({ ...written, reported: UNSCOPED_ENTRY });
+        refusals.push({ ...written, reported: CODE.unscopedIgnoreEntry });
     }
     if (refusals.length > 0) {
         return { records: [], refusals };
@@ -131,28 +130,27 @@ function byReferenceOf(symbols) {
 }
 /** Reads one document at the target root, binding each record against the run's declarations. */
 function readDocument(host, targetRoot, symbols, shape) {
-    const file = joinPath(targetRoot, shape.file);
-    if (host.kindOf(file) === "absent") {
+    const text = readTargetDocument(host, targetRoot, shape.file);
+    if (text === undefined) {
         return { records: [], refusals: [] };
     }
-    const text = host.readFile(file);
     const malformed = (detail, site = documentSite(shape)) => {
         throw new SuppressionError(shape.mechanism, siteText(site), detail, shape.documentWant);
     };
-    let parsed;
+    let document;
     try {
-        parsed = JSON.parse(text);
+        document = readStrict(text, shape.array);
     }
     catch (error) {
-        return malformed(`${shape.file}: ${error instanceof Error ? error.message : String(error)}`);
+        if (!(error instanceof StrictJSONError)) {
+            throw error;
+        }
+        return malformed(error.message, positionAt(text, shape.file, error.offset));
     }
-    if (!isObject(parsed)) {
+    const parsed = document.value;
+    if (!isRecord(parsed)) {
         return malformed(shape.file);
     }
-    const walk = walkDocument(text, shape.array);
-    if (walk.twice !== undefined) {
-        malformed(`the member ${JSON.stringify(walk.twice.name)} is written twice, so neither value is chosen`, positionAt(text, shape.file, walk.twice.offset));
-    }
     for (const key of Object.keys(parsed)) {
         if (key !== "description" && key !== shape.array) {
             malformed(`the member ${JSON.stringify(key)} is not one the grammar declares`);
@@ -167,7 +165,7 @@ function readDocument(host, targetRoot, symbols, shape) {
     const records = [];
     const refusals = [];
     held.forEach((value, index) => {
-        const offset = walk.starts[index];
+        const offset = document.starts.get(index);
         const site = offset === undefined ? documentSite(shape) : positionAt(text, shape.file, offset);
         const read = readRecord(value, site, byReference, shape);
         records.push(...read.records);
@@ -227,9 +225,9 @@ export function otherSchemeRows(text, own = OWN_SCHEME) {
         parsed = JSON.parse(text);
     }
     catch (error) {
-        return refuse(error instanceof Error ? error.message : String(error));
+        return refuse(message(error));
     }
-    const held = isObject(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
+    const held = isRecord(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
     if (!Array.isArray(held)) {
         return refuse(BASELINE_SHAPE.documentWant);
     }
@@ -238,7 +236,7 @@ export function otherSchemeRows(text, own = OWN_SCHEME) {
             readRecord(value, documentSite(BASELINE_SHAPE), new Map(), BASELINE_SHAPE);
         }
         catch (error) {
-            return refuse(error instanceof Error ? error.message : String(error));
+            return refuse(message(error));
         }
         // readRecord has checked every member is a string and the code and symbol are present.
         const { code, symbol, path, reason } = value;
@@ -279,10 +277,9 @@ function* separatorsEscaped(pieces) {
  * A baseline holding one row per finding, in the order given, which is the report's, and
  * the other language's rows `kept`, Go's rows ahead of TypeScript's and each scheme's in
  * the order given, so two analyzers writing one document in either order write the same
- * bytes, in the form grammar/suppression.md fixes. Every recorded row carries the
- * provenance as its reason. A finding
- * missing a value a row needs, and an identity missing its name or version, are refused
- * rather than written, because the grammar requires a reason on every row.
+ * bytes, in the form grammar/suppression.md fixes. Every row carries the provenance as
+ * its reason, so a finding missing a value a row needs, or an identity missing its name
+ * or version, is refused rather than written.
  */
 export function writeBaseline(findings, provenance, kept = []) {
     if (provenance.analyzer === "" || provenance.version === "") {

package/dist/src/suppress-inline.js

@@ -3,13 +3,14 @@
  * one or more codes and a reason, and binding to every declaration that begins on the line
  * below it, or on its own line where it trails a token there.
  */
+import { CODE } from "./contract/contract.generated.js";
 import { isConstructorDeclaration, SyntaxKind, } from "@typescript/native/ast";
 import { importBindings } from "./import-bindings.js";
 import { isParameterProperty, nodeKey } from "./inventory.js";
 import { byPosition, positionKey, renderPosition } from "./position.js";
 import { importRef } from "./ref.js";
 import { signatureOf } from "./signatures.js";
-import { isPartKind, SUPPRESSION_WITHOUT_REASON, SuppressionError, siteText, } from "./suppress.js";
+import { isPartKind, SuppressionError, siteText, } from "./suppress.js";
 /**
  * The three expressions the grammar applies to the text of each line comment, in this
  * order: a comment in the namespace, a well-formed directive, and a directive that lacks
@@ -274,7 +275,7 @@ export function inlineSuppressions(perProject) {
             case "no-reason":
                 for (const code of directive.codes) {
                     refusals.push({
-                        reported: SUPPRESSION_WITHOUT_REASON,
+                        reported: CODE.suppressionWithoutReason,
                         code,
                         symbol: "",
                         path: site.path,

package/dist/src/suppress.js

@@ -6,23 +6,18 @@
  * withholds a finding its code would have produced there, dormant when the configuration
  * withholds every such finding anyway, and stale otherwise.
  */
-import { ConfigError } from "./config.js";
+import { KIND_ROWS, SYMBOL_SUBJECTS, } from "./contract/contract.generated.js";
+import { UsageError } from "./usage.js";
 import { positionKey } from "./position.js";
 import { isRef } from "./ref.js";
-/** The code a suppression that carries no reason is reported under. */
-export const SUPPRESSION_WITHOUT_REASON = "DS1701";
-/** The code an ignore entry or a baseline row that names no path is reported under. */
-export const UNSCOPED_ENTRY = "DS1702";
-/** The code a suppression that withholds nothing is reported under. */
-export const STALE_SUPPRESSION = "DS1703";
 /**
  * A directive, an entry or a document the grammar refuses before any finding exists: an
  * instruction the analysis cannot carry out. It is a malformed input, so the command line
  * answers it with the usage code.
  */
-export class SuppressionError extends ConfigError {
+export class SuppressionError extends UsageError {
     constructor(mechanism, at, text, want) {
-        super("malformed", at, `${mechanism} ${at}: ${text}: want ${want}`);
+        super(`${mechanism} ${at}: ${text}: want ${want}`);
         this.name = "SuppressionError";
     }
 }
@@ -57,6 +52,7 @@ export const GO_REF_EXPRESSIONS = [
     `^go://${GO_PATH}#${GO_IDENT}$`,
     `^go://${GO_PATH}#${GO_IDENT}(?:\\.${GO_IDENT})+$`,
     `^go://${GO_PATH}#${GO_IDENT}(?:\\.${GO_IDENT})?\\[${GO_IDENT}\\]$`,
+    `^go://${GO_PATH}#(?:${GO_IDENT}(?:\\.${GO_IDENT})?)?\\(${GO_IDENT}\\)$`,
     `^go://${GO_PATH}#${GO_FILE}:file$`,
     `^go://${GO_PATH}#${GO_PATH}(?:@${GO_VERSION})?:require$`,
     `^go://${GO_PATH}#${GO_PATH}(?:@${GO_VERSION})?:replace$`,
@@ -70,73 +66,59 @@ export function isSymbolRef(value) {
 export function blankReason(reason) {
     return reason === undefined || /^[ \t\r\n]*$/u.test(reason);
 }
+/** The subject of the kind each live code names. */
+const SUBJECT_OF_CODE = new Map(KIND_ROWS.map((row) => [row.code, row.subject]));
+/** The subject a finding about one symbol kind is about. */
+function subjectOf(kind) {
+    return Object.hasOwn(SYMBOL_SUBJECTS, kind)
+        ? SYMBOL_SUBJECTS[kind]
+        : undefined;
+}
+/** Whether a subject is a row of a document rather than a declaration of the program. */
+function rowOf(subject) {
+    return subject === "file" || subject === "dependency" || subject === "record";
+}
 /**
- * The subject kinds that are a dependency row, each with the code that reports one. An
- * ignore entry or a baseline row naming the row's reference and file withholds its finding
- * and marks nothing, and an inline directive never binds one.
- */
-const DEPENDENCY_SUBJECTS = new Map([
-    ["dependency", ["DS1601"]],
-    ["module-directive", ["DS1605"]],
-]);
-/**
- * The subject kinds that are a row of a document rather than a declaration of the program,
- * each with the codes that report one. Apart from a dependency row, nothing withholds a
- * finding about one.
+ * Whether a finding's subject is a row of a document rather than a declaration. Apart
+ * from a dependency row, nothing withholds a finding about one.
  */
-const ROW_SUBJECTS = new Map([
-    ["file", ["DS1501", "DS1502"]],
-    ...DEPENDENCY_SUBJECTS,
-    ["root", ["DS1704"]],
-    ["configured-declaration", ["DS1706"]],
-    ["suppression", ["DS1701", "DS1702", "DS1703"]],
-    ["edge", ["DS1705"]],
-]);
-/** Whether a finding's subject is a row of a document rather than a declaration. */
 export function isRowSubject(kind) {
-    return ROW_SUBJECTS.has(kind);
+    return rowOf(subjectOf(kind));
 }
 /** Whether a code reports a row of a document. */
 export function isRowCode(code) {
-    return [...ROW_SUBJECTS.values()].some((codes) => codes.includes(code));
+    return rowOf(SUBJECT_OF_CODE.get(code));
 }
-/** Whether a finding's subject is a dependency row. */
+/**
+ * Whether a finding's subject is a dependency row. An ignore entry or a baseline row
+ * naming the row's reference and file withholds its finding and marks nothing, and an
+ * inline directive never binds one.
+ */
 export function isDependencySubject(kind) {
-    return DEPENDENCY_SUBJECTS.has(kind);
+    return subjectOf(kind) === "dependency";
 }
 /** Whether a code reports a dependency row, which only an ignore entry or a baseline row names. */
 export function isDependencyCode(code) {
-    return [...DEPENDENCY_SUBJECTS.values()].some((codes) => codes.includes(code));
+    return SUBJECT_OF_CODE.get(code) === "dependency";
 }
 /** Whether a code reports a row of a document that no record of any mechanism can name. */
 export function isUnsuppressibleCode(code) {
     return isRowCode(code) && !isDependencyCode(code);
 }
 /**
- * The subject kinds that are a part of a declaration rather than a declaration: a part
+ * Whether a finding's subject is a part of the declaration its reference names: a part
  * has no reference of its own, so a finding about one names the declaration that holds
  * it, and the part is decided inside that declaration whatever uses it.
  */
-const PART_SUBJECTS = new Set([
-    "parameter",
-    "receiver",
-    "result",
-    "statement",
-    "case",
-    "store",
-]);
-/** Whether a finding's subject is a part of the declaration its reference names. */
 export function isPartSubject(kind) {
-    return PART_SUBJECTS.has(kind);
+    return subjectOf(kind) === "part";
 }
-/** The prefix of the codes of the part kinds, the intra-function range. */
-const PART_KIND_PREFIX = "DS18";
 /**
  * Whether a code is a part kind, whose record withholds its finding and marks nothing:
  * the record says the part is wanted, not that the declaration holding it is.
  */
 export function isPartKind(code) {
-    return code.startsWith(PART_KIND_PREFIX);
+    return SUBJECT_OF_CODE.get(code) === "part";
 }
 /** One finding's identity: its code and the position of the thing it names. */
 function claimKey(finding) {
@@ -154,12 +136,12 @@ export function pairs(record, finding) {
     if (record.code !== finding.code) {
         return false;
     }
-    if (DEPENDENCY_SUBJECTS.has(finding.symbol.kind)) {
+    if (isDependencySubject(finding.symbol.kind)) {
         return (record.mechanism !== "inline" &&
             record.symbol === finding.symbol.ref &&
             record.path === finding.position.path);
     }
-    if (ROW_SUBJECTS.has(finding.symbol.kind)) {
+    if (isRowSubject(finding.symbol.kind)) {
         return false;
     }
     if (record.bound !== "" && record.bound === positionKey(finding.position)) {

package/dist/src/sweep.js

@@ -84,10 +84,10 @@ export function runnerCalls(symbol) {
  * That run's roots are the graph's own and, of each test file, its top level and every
  * function it exports, which a test runner may call, and every export of a manual mock,
  * which the runner reads; any other export of a test file, and test-support code, which
- * runs where a test imports it, are judged as any file's are.
- * `held` seeds it as a mark or an exemption seeds a sweep.
+ * runs where a test imports it, are judged as any file's are. `held` seeds it as a mark
+ * seeds a sweep; with `namespaces` false a file read reaches none of the file's exports.
  */
-export function reachedWithTheTests(graph, held) {
+export function reachedWithTheTests(graph, held, namespaces = true) {
     const tests = graph.symbols.flatMap((symbol, at) => {
         const exported = symbol.exported && graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
         const called = exported && runnerCalls(symbol);
@@ -97,9 +97,7 @@ export function reachedWithTheTests(graph, held) {
             ? [{ at, kind: "test-runner" }]
             : [];
     });
-    return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), {
-        production: false,
-    });
+    return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), { production: false }, namespaces);
 }
 /**
  * The references a loaded consumer makes that the mode counts. A production mode counts
@@ -126,7 +124,7 @@ function flagged(graph, ids) {
  * included, while a root reaches through the references the mode counts. The held seed
  * runs first, so what it reaches is expanded under the wider rule.
  */
-function reachable(graph, held, mode) {
+function reachable(graph, held, mode, namespaces = true) {
     const reached = graph.symbols.map(() => false);
     const expanded = graph.symbols.map(() => false);
     const queue = [];
@@ -154,7 +152,7 @@ function reachable(graph, held, mode) {
                 if (!holding && mode.production && edge.test) {
                     continue;
                 }
-                enter(edge.to, !edge.evaluation);
+                enter(edge.to, namespaces && !edge.evaluation);
             }
         }
     };
@@ -169,7 +167,7 @@ function reachable(graph, held, mode) {
     }
     // A consumer's reference reaches what it names as one of the target's own does.
     for (const edge of callsOf(graph, mode)) {
-        enter(edge.to, !edge.evaluation);
+        enter(edge.to, namespaces && !edge.evaluation);
     }
     walk(false);
     return reached;

package/dist/src/symbol-keys.js

@@ -5,16 +5,14 @@
  * No name node resolves to such a member: the key's name resolves to the constant. An
  * iteration reads the member its well-known iteration symbol keys.
  */
-import { isComputedPropertyName, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPropertyAccessExpression, isSpreadElement, isStringLiteral, } from "@typescript/native/ast";
+import { isComputedPropertyName, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isPropertyAccessExpression, isSpreadElement, isStringLiteral, } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { isAnswered } from "./query.js";
 /** The identifier an element access's argument names its key by, where it is a name. */
 export function keyNameOf(argument) {
-    let at = argument;
-    while (isParenthesizedExpression(at)) {
-        at = at.expression;
-    }
+    const at = parenthesesRemoved(argument);
     if (isIdentifier(at)) {
         return at;
     }

package/dist/src/template-field.js

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

package/dist/src/test-support.js

@@ -5,21 +5,18 @@
  * another such file, so it is judged with the tests: what it references is referenced by
  * test code.
  */
-import { CONVENTION_ROWS } from "./convention-rows.js";
+import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./convention-rows.js";
 import { packageOfSpecifier } from "./dependencies.js";
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
 /**
  * The test runners and test libraries an import of which is test evidence: each runner a
- * convention row reads test files for, the platform's own runner, and the libraries below.
+ * convention row reads test files for, and the convention table's test libraries.
  */
 const TEST_PACKAGES = new Set([
     ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined).map((row) => row.package),
-    "node:test",
-    "@playwright/test",
+    ...TEST_LIBRARIES,
 ]);
-/** The scopes every package of which is a test library. */
-const TEST_SCOPES = ["@testing-library/"];
 /**
  * The Node.js built-in modules a bare specifier names, which are no package. The set is
  * closed: Node.js adds a new built-in under the `node:` scheme alone
@@ -73,7 +70,7 @@ const NODE_BUILTINS = new Set([
 function namesTestPackage(specifier) {
     const name = specifier.startsWith("node:") ? specifier : packageOfSpecifier(specifier);
     return (name !== undefined &&
-        (TEST_PACKAGES.has(name) || TEST_SCOPES.some((scope) => name.startsWith(scope))));
+        (TEST_PACKAGES.has(name) || TEST_LIBRARY_SCOPES.some((scope) => name.startsWith(scope))));
 }
 /**
  * Whether a file carries test evidence: an import of a test runner or a test library, or
@@ -106,9 +103,9 @@ function evidenceReader(tests, evidence) {
  * The files of one project that are test-support code, below the target root: the
  * largest set of files a test file reaches, none of them a test file or holding a root,
  * each carrying test evidence of its own, whose every user outside the set is a test
- * file. A root has a caller outside the reference graph: a runtime, a tool, a
- * configuration, or a consumer of a library's published API. `testFiles` are the files
- * the test-file rules classified.
+ * file; and the files only tests reach that are not among them. A root has a caller
+ * outside the reference graph: a runtime, a tool, a configuration, or a consumer of a
+ * library's published API. `testFiles` are the files the test-file rules classified.
  */
 export function testSupportFiles(symbols, references, roots, testFiles, evidence) {
     const fileOf = new Map(symbols.map((symbol) => [symbol.id, symbol.position.path]));
@@ -162,7 +159,7 @@ export function testSupportFiles(symbols, references, roots, testFiles, evidence
     const onlyTests = withoutOutsideUsers(new Set([...reached].filter((path) => !rooted.has(path))));
     const carries = evidenceReader(tests, evidence);
     const support = withoutOutsideUsers(new Set([...onlyTests].filter((path) => carries(onlyTests, path))));
-    return support;
+    return { support, testUsed: new Set([...onlyTests].filter((path) => !support.has(path))) };
 }
 /** The references with every one a test-support file makes counted as a test reference. */
 export function supportReferences(references, support) {

package/dist/src/text/compare.js

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