@cplieger/deadset-ts 8.0.0-dev.6 → 8.0.0-dev.7

package/dist/src/discover.js

@@ -3,10 +3,15 @@ import { baseUrlPaths } from "./base-url.js";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { SetupError } from "./setup-failure.js";
 import { writtenPath } from "./workspace-programs.js";
-/** Directory names discovery does not descend into. */
-export const IGNORED_DIRECTORIES = new Set(["node_modules", ".git"]);
-/** A compiler configuration file discovery recognises under a root. */
-const CONFIG_FILE = /^tsconfig.*\.json$/u;
+import { filesBelow } from "./fs/tree.js";
+import { LANGUAGE, message } from "./product.js";
+import { LANGUAGE_ROWS } from "./contract/contract.generated.js";
+import { globExpression } from "./text/glob.js";
+const MARKERS = LANGUAGE_ROWS[LANGUAGE].markers.map(globExpression);
+/** Whether one file name is a compiler configuration's: one of the language row's markers. */
+export function isConfigFile(name) {
+    return MARKERS.some((marker) => marker.test(name));
+}
 /**
  * A run that cannot read what it was asked to analyze. It ends the run with the
  * failure code and no finding list: a configuration file the compiler cannot read,
@@ -111,40 +116,9 @@ export function targetRelative(text, targetRoot) {
 export function isGuess(discovery, configFile) {
     return discovery.derived && !discovery.fromScope.includes(configFile);
 }
-/**
- * The configuration files below `root`, in ascending path order, skipping an
- * ignored directory. A directory that cannot be read is skipped: a tree the
- * analysis may not enter names no project.
- */
+/** The configuration files below `root`, by absolute path in ascending order. */
 function configFilesUnder(host, root) {
-    const found = [];
-    const pending = [root];
-    while (pending.length > 0) {
-        const dir = pending.pop();
-        if (dir === undefined) {
-            break;
-        }
-        let entries;
-        try {
-            entries = host.readDirectory(dir);
-        }
-        catch {
-            continue;
-        }
-        for (const entry of [...entries].sort((a, b) => (a.name < b.name ? -1 : 1))) {
-            const path = joinPath(dir, entry.name);
-            if (entry.directory) {
-                if (!IGNORED_DIRECTORIES.has(entry.name)) {
-                    pending.push(path);
-                }
-                continue;
-            }
-            if (CONFIG_FILE.test(entry.name)) {
-                found.push(path);
-            }
-        }
-    }
-    return found.sort();
+    return filesBelow(host, root, isConfigFile).map((path) => joinPath(root, path));
 }
 /**
  * The configuration file the scope names for the target directly, where its path
@@ -211,7 +185,7 @@ export function consumerProjects(engine, host, root) {
     if (kind !== "directory") {
         throw new DiscoveryError(`the consumer ${root} is not a directory`, []);
     }
-    const found = derivedFrom(engine, host, configFilesUnder(host, root), () => true);
+    const found = derivedFrom(engine, host, [...configFilesUnder(host, root)], () => true);
     if (found.length === 0) {
         throw new DiscoveryError(`the consumer ${root} holds no compiler configuration, so none of its references can be read`, []);
     }
@@ -253,7 +227,7 @@ function readConfiguration(engine, configFile) {
             : { reason: `TS${String(circular.code)}: ${circular.text.replace("{0}", () => configFile)}` };
     }
     catch (error) {
-        return { reason: error instanceof Error ? error.message : String(error) };
+        return { reason: message(error) };
     }
 }
 /**

package/dist/src/edges.js

@@ -5,10 +5,12 @@
  * pairing is a use, and the merge reads the two evaluations together.
  */
 import { ConfigError } from "./config.js";
-import { positionAt, walkDocument } from "./json-document.js";
+import { isRecord, positionAt, walkDocument } from "./json-document.js";
 import { joinPath } from "./paths.js";
 import { positionKey } from "./position.js";
 import { isPartSubject } from "./suppress.js";
+import { bytewise } from "./text/compare.js";
+import { message } from "./product.js";
 /** The name and the location the Contract fixes for the edges document. */
 export const EDGES_FILE = "deadset-edges.json";
 /** The language prefix of every reference this analyzer evaluates. */
@@ -64,15 +66,12 @@ function carriesWildcard(ref) {
     }
     return false;
 }
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 /** One edge, checked: the closed key list, the value types and the value forms. */
 function readEdge(value, at) {
     const refuse = (text, want) => {
         throw new EdgesError(at, text, want);
     };
-    if (!isObject(value)) {
+    if (!isRecord(value)) {
         return refuse(JSON.stringify(value), EDGE_WANT);
     }
     for (const [key, held] of Object.entries(value)) {
@@ -111,9 +110,9 @@ export function readEdgeSides(host, targetRoot) {
         parsed = JSON.parse(text);
     }
     catch (error) {
-        throw new EdgesError(EDGES_FILE, error instanceof Error ? error.message : String(error), DOCUMENT_WANT);
+        throw new EdgesError(EDGES_FILE, message(error), DOCUMENT_WANT);
     }
-    if (!isObject(parsed)) {
+    if (!isRecord(parsed)) {
         throw new EdgesError(EDGES_FILE, JSON.stringify(parsed), DOCUMENT_WANT);
     }
     const walk = walkDocument(text, "edges");
@@ -145,13 +144,6 @@ export function readEdgeSides(host, targetRoot) {
     });
     return sides;
 }
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /**
  * Evaluates every declared side of this language over the run's findings. A side naming a
  * symbol the run enumerates nothing under is `absent`; otherwise it is evaluated once per
@@ -191,6 +183,6 @@ export function evaluateEdges(findings, sides, symbols) {
             return { ...side, state: "dead", finding };
         });
     });
-    evaluations.sort((a, b) => compare(a.edge, b.edge) || compare(a.side, b.side));
+    evaluations.sort((a, b) => bytewise(a.edge, b.edge) || bytewise(a.side, b.side));
     return { findings: findings.filter((_finding, at) => !pending.has(at)), evaluations };
 }

package/dist/src/element-access.js

@@ -8,6 +8,7 @@ import { isArrayLiteralExpression, isArrowFunction, isBinaryExpression, isCallEx
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
+import { parenthesesRemoved } from "./unwrap.js";
 /** The assignment operators that read their target before they write it. */
 const COMPOUND = new Set([
     SyntaxKind.PlusEqualsToken,
@@ -47,12 +48,9 @@ function useOf(node) {
     }
     return "read";
 }
-function unwrapped(node) {
-    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
 /** Whether an index is a literal the checker resolves to a member by its own text. */
 function isLiteralIndex(node) {
-    const at = unwrapped(node);
+    const at = parenthesesRemoved(node);
     return isStringLiteral(at) || isNumericLiteral(at) || isNoSubstitutionTemplateLiteral(at);
 }
 /**
@@ -195,7 +193,7 @@ export function elementAccessReferences(project, held, chains, root, testFiles)
     const parameterOf = new Map();
     const byCallable = new Map();
     for (const candidate of candidates) {
-        const index = unwrapped(candidate.access.argumentExpression);
+        const index = parenthesesRemoved(candidate.access.argumentExpression);
         const fn = isIdentifier(index) ? enclosingFunction(candidate.access) : undefined;
         const callable = fn === undefined ? undefined : callableOf(fn);
         if (callable === undefined || !isIdentifier(index)) {
@@ -252,7 +250,7 @@ export function elementAccessReferences(project, held, chains, root, testFiles)
             continue;
         }
         // An object that is a parameter too is read as the argument each call passes there.
-        const object = unwrapped(candidate.access.expression);
+        const object = parenthesesRemoved(candidate.access.expression);
         const objectAt = isIdentifier(object)
             ? deferred.callable.parameters.findIndex((parameter) => isIdentifier(parameter.name) && parameter.name.text === object.text)
             : -1;

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

@@ -7,6 +7,7 @@
  * Every row carries a reason, because the list is read where the rows are shown
  * one at a time: beside a finding, or in a report's declared gaps.
  */
+import { bytewise } from "./text/compare.js";
 /** What is declined for a tool whose own conventions are entered only through its configuration files. */
 const EVERY_CONVENTION = "every file it loads by its own convention beyond its configuration files";
 /** Why a tool whose own conventions are not read declines them. */
@@ -291,15 +292,8 @@ const PARTLY_ENTERED = [
         reason: NOT_LITERAL,
     },
 ];
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /** Every declined entry-point convention, ordered by tool and then by convention. */
 export const DECLINED_CONVENTIONS = [
     ...UNREAD_TOOLS.map((tool) => ({ tool, convention: EVERY_CONVENTION, reason: UNREAD })),
     ...PARTLY_ENTERED,
-].sort((a, b) => compare(a.tool, b.tool) || compare(a.convention, b.convention));
+].sort((a, b) => bytewise(a.tool, b.tool) || bytewise(a.convention, b.convention));

package/dist/src/entry-points.js

@@ -10,17 +10,18 @@
  * value that is not a literal is not evaluated and not guessed, so a file it would
  * have named is entered by nothing here.
  */
-import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.js";
 import { buildScriptEntries } from "./build-scripts.js";
-import { globExpression } from "./glob.js";
 import { htmlEntries } from "./html-entries.js";
 import { documentEntries } from "./mdx-entries.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 import { computedLoadDirectory, leadingLiteral } from "./unseen-loads.js";
 import { workflowEntries } from "./workflow-steps.js";
+import { unwrapped } from "./unwrap.js";
+import { globExpression } from "./text/glob.js";
 /** The extensions the test runner and the browser-test runner load a configuration from. */
 const MODULE_EXTENSIONS = ["js", "mjs", "cjs", "ts", "mts", "cts"];
 /** The tool file names the configuration form does not cover. */
@@ -69,14 +70,6 @@ function literalOf(node) {
     }
     return undefined;
 }
-/** The expression a wrapper that changes no value holds: parentheses and type assertions. */
-function unwrapped(node) {
-    let at = node;
-    while (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
-        at = at.expression;
-    }
-    return at;
-}
 /**
  * The object literals one configuration file's default export is written as: the
  * literal itself, or each literal argument of the call it is, at any depth of calls.

package/dist/src/enum-group.js

@@ -6,7 +6,8 @@
  * or `unknown` expression asserted to it, or bound to a variable or returned from a
  * function it annotates, where a number counts too. An enum's own value converts nothing.
  */
-import { isArrowFunction, isAsExpression, isElementAccessExpression, isEnumDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isParenthesizedExpression, isParenthesizedTypeNode, isPropertyAccessExpression, isReturnStatement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { isArrowFunction, isAsExpression, isElementAccessExpression, isEnumDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isParenthesizedTypeNode, isPropertyAccessExpression, isReturnStatement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.js";
 import { TypeFlags } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
 import { nodeKey } from "./inventory.js";
@@ -16,14 +17,6 @@ import { isAnswered, UNANSWERED } from "./query.js";
 const NUMBER = TypeFlags.NumberLike;
 const STRING = TypeFlags.StringLike;
 const DECODED = TypeFlags.Any | TypeFlags.Unknown;
-/** The expression one node is, through however many parentheses are written around it. */
-function unparenthesized(node) {
-    let held = node;
-    while (isParenthesizedExpression(held)) {
-        held = held.expression;
-    }
-    return held;
-}
 /**
  * The name node a type node names its declaration by: the identifier of a type
  * reference, the right side of a qualified one, through parentheses. A type that is no
@@ -45,7 +38,7 @@ function typeName(type) {
 }
 /** The name node an expression names an object by: an identifier, or a property access's name. */
 function objectName(expression) {
-    const held = unparenthesized(expression);
+    const held = parenthesesRemoved(expression);
     if (isIdentifier(held)) {
         return held;
     }

package/dist/src/erased-stores.js

@@ -6,10 +6,11 @@
  * either stores. A store into an erased property of a type the analyzed program does not
  * declare hands the value to the code that declares it.
  */
-import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags, TypeFlags } from "@typescript/native/sync";
 import { must } from "./query.js";
 import { checkedTypes } from "./value-reach.js";
+import { parenthesesRemoved } from "./unwrap.js";
 /** The types that keep nothing of the value they are given. */
 const ERASED = TypeFlags.Any | TypeFlags.Unknown;
 /** The array methods whose arguments become elements of the array they are called on. */
@@ -20,9 +21,6 @@ function literalKey(node) {
         ? node.text
         : undefined;
 }
-function unwrapped(node) {
-    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
 /**
  * Whether a variable declaration's type can differ from what is stored in it: it carries an
  * annotation, or it has neither an annotation nor an initializer, so its type evolves.
@@ -76,8 +74,8 @@ function propertyAt(source, name) {
  * here, and a default value is stored in its target too.
  */
 function patternTargets(pattern, from, out) {
-    const target = unwrapped(pattern);
-    const source = from.path.length === 0 ? unwrapped(from.value) : from.value;
+    const target = parenthesesRemoved(pattern);
+    const source = from.path.length === 0 ? parenthesesRemoved(from.value) : from.value;
     const into = (element, step, literal) => {
         patternTargets(element, literal === undefined
             ? { value: from.value, path: [...from.path, step] }

package/dist/src/exempt-classes.js

@@ -11,7 +11,5 @@ const VISIBILITY = new Map(TS_ROWS.map((row) => [row.class, row.typescriptVisibi
 export function typescriptVisibilityOf(exemptionClass) {
     return VISIBILITY.get(exemptionClass) ?? { private: false, privateName: false };
 }
-/** Whether one name is a class of the vocabulary, whichever language it runs on. */
-export function isExemptionClass(name) {
-    return EXEMPTION_CLASSES.some((row) => row.class === name);
-}
+/** Every class of the vocabulary, whichever language it runs on, in the vocabulary's order. */
+export const EXEMPTION_CLASS_NAMES = EXEMPTION_CLASSES.map((row) => row.class);

package/dist/src/exempt.js

@@ -7,26 +7,17 @@
  * hands it the table of the classes it has.
  */
 import { EXEMPTION_CLASSES } from "./contract/contract.generated.js";
-import { ConfigError } from "./config.js";
-import { isExemptionClass, TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
+import { TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
 import { byPosition, positionKey } from "./position.js";
 import { Unanswerable } from "./query.js";
 import { sweep } from "./sweep.js";
+import { bytewise } from "./text/compare.js";
 /**
- * The classes `exemptions.disabled` switches off. A name is refused unless the
- * vocabulary holds it; a class that runs on another language only is admitted and
- * switches nothing off here, so one configuration serves every analyzer.
+ * The classes `exemptions.disabled` switches off. A class that runs on another language
+ * only switches nothing off here, so one configuration serves every analyzer.
  */
 export function disabledClasses(config) {
-    const disabled = new Set();
-    for (const name of config.exemptionsDisabled) {
-        if (!isExemptionClass(name)) {
-            const known = EXEMPTION_CLASSES.map((row) => row.class).join(", ");
-            throw new ConfigError("malformed", "exemptions.disabled", `exemptions.disabled: ${JSON.stringify(name)} is not an exemption class: the classes are ${known}`);
-        }
-        disabled.add(name);
-    }
-    return disabled;
+    return new Set(config.exemptionsDisabled);
 }
 /**
  * Whether a class whose row states `allowed` may retain a member of one visibility. A
@@ -122,20 +113,13 @@ export function heldRecords(records, holding) {
     }
     return { records: exemptionsOf(found), inTestFiles };
 }
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /**
  * Records as a run holds them: ordered by site, then class, then declaration, and one
  * per declaration, class, detail and file it holds while live, the one at the first
  * site. A fact found at many sites, or by several projects, is one record.
  */
 export function exemptionsOf(found) {
-    const ordered = [...found].sort((a, b) => byPosition(a.site, b.site) || compare(a.class, b.class) || compare(a.id, b.id));
+    const ordered = [...found].sort((a, b) => byPosition(a.site, b.site) || bytewise(a.class, b.class) || bytewise(a.id, b.id));
     const seen = new Set();
     return ordered.filter((record) => {
         const fact = [record.id, record.class, record.detail, record.whileLive ?? ""].join("\u0000");

package/dist/src/file-facts.js

@@ -3,10 +3,10 @@
  * file below the target root, whether or not a project includes it, and the files a
  * program holds by inclusion rather than by an import.
  */
-import { IGNORED_DIRECTORIES } from "./discover.js";
 import { packageScope } from "./inventory.js";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { renderRef } from "./ref.js";
+import { filesBelow } from "./fs/tree.js";
 /** A file name the compiler reads as a source file. */
 const SOURCE_FILE = /\.(?:ts|tsx|mts|cts)$/u;
 /** A file name the compiler reads as a declaration file, which no build emits code from. */
@@ -30,30 +30,7 @@ function lastLine(text) {
  * that cannot be read is skipped, as discovery skips it.
  */
 export function sourcePaths(host, targetRoot) {
-    const found = [];
-    const pending = [""];
-    for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
-        let entries;
-        try {
-            entries = host.readDirectory(joinPath(targetRoot, dir));
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
-            if (entry.directory) {
-                if (!IGNORED_DIRECTORIES.has(entry.name)) {
-                    pending.push(path);
-                }
-                continue;
-            }
-            if (SOURCE_FILE.test(entry.name) && !DECLARATION_FILE.test(entry.name)) {
-                found.push(path);
-            }
-        }
-    }
-    return found.sort((a, b) => (a < b ? -1 : 1));
+    return filesBelow(host, targetRoot, (name) => SOURCE_FILE.test(name) && !DECLARATION_FILE.test(name));
 }
 /**
  * Every source file below the target root, in path order. A file that cannot be read is

package/dist/src/findings/reads-and-writes.js

@@ -1,6 +1,7 @@
 import { CODE } from "../contract/contract.generated.js";
 import { positionKey } from "../position.js";
 import { declarationKey } from "../ref.js";
+import { bytewise } from "../text/compare.js";
 /** The containers whose type parameters `DS1006` reports: a function, a class method and a type alias. */
 const SIGNATURES = new Set(["function", "method", "type"]);
 function indexed(input) {
@@ -76,7 +77,7 @@ function writeOnlyMessage(run, namedBy, symbol, held) {
         : "never read";
     const cascade = [
         ...parametersOnlyNamedBy(run, namedBy, symbol).map((name) => `type parameter ${name}`),
-        ...[...held.alone].sort().map((name) => `import ${name}`),
+        ...[...held.alone].sort(bytewise).map((name) => `import ${name}`),
     ];
     const word = SUBJECT_WORDS[symbol.kind] ?? "member";
     const message = `${word} ${symbol.name} is written ${writes} and ${read}`;

package/dist/src/findings/self-check.js

@@ -2,6 +2,7 @@ import { CODE } from "../contract/contract.generated.js";
 import { REPOSITORY_DOCUMENT } from "../config.js";
 import { FIXED_SEVERITY_CODES } from "../kinds.js";
 import { isDependencyCode, isUnsuppressibleCode, } from "../suppress.js";
+import { bytewise } from "../text/compare.js";
 /** The subject kind of a finding about a configured declaration. */
 const DECLARATION_SUBJECT = "configured-declaration";
 /** The subject kind of a finding about a suppression record. */
@@ -80,10 +81,10 @@ export function staleSuppressions(stale, files) {
         bySite.set(key, held);
     }
     return [...bySite.values()].map(({ first, records }) => {
-        const codes = [...new Set(records.map((one) => one.record.code))].sort();
+        const codes = [...new Set(records.map((one) => one.record.code))].sort(bytewise);
         const reports = [...new Set(records.flatMap((one) => one.reports))]
             .filter((code) => !codes.includes(code))
-            .sort();
+            .sort(bytewise);
         const rows = codes.filter(isUnsuppressibleCode);
         const dependencies = first.mechanism === "inline" ? codes.filter(isDependencyCode) : [];
         const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));

package/dist/src/findings-pass.js

@@ -8,20 +8,15 @@ import { fails } from "./config.js";
 import { decidedFindings } from "./findings/emitters.js";
 import { fileRefsOf, staleSuppressions, } from "./findings/self-check.js";
 import { isDependencySubject, isRowSubject, pairs, suppressionCounts, } from "./suppress.js";
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
+import { bytewise } from "./text/compare.js";
+import { PRODUCT } from "./product.js";
 /** The canonical order: path, line, column, code, then the symbol reference. */
 function canonical(a, b) {
-    return (compare(a.position.path, b.position.path) ||
+    return (bytewise(a.position.path, b.position.path) ||
         a.position.line - b.position.line ||
         a.position.column - b.position.column ||
-        compare(a.code, b.code) ||
-        compare(a.symbol.ref, b.symbol.ref));
+        bytewise(a.code, b.code) ||
+        bytewise(a.symbol.ref, b.symbol.ref));
 }
 /**
  * The pass over one run. The emitter table decides every record against every finding the
@@ -98,5 +93,5 @@ export function rowKey(row) {
 }
 /** The analyzer identity a baseline this analyzer writes names as its rows' provenance. */
 export function analyzerProvenance(version) {
-    return { analyzer: "deadset-ts", version };
+    return { analyzer: PRODUCT, version };
 }

package/dist/src/fs/manifest.js

@@ -0,0 +1,43 @@
+import { isRecord } from "../json-document.js";
+import { joinPath } from "../paths.js";
+/** The file a package's manifest is read from. */
+export const MANIFEST = "package.json";
+/** The directory a package manager installs packages into, whose files are no project's own. */
+export const INSTALLED_PACKAGES = "node_modules";
+/** Whether one path passes through an installed-packages directory. */
+export function inInstalledPackages(path) {
+    return path.split("/").includes(INSTALLED_PACKAGES);
+}
+/** One JSON file's text and decoded value, or undefined where it cannot be read or parsed. */
+export function readDocument(host, path) {
+    let text;
+    try {
+        text = host.readFile(path);
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        return { text, value: JSON.parse(text) };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** One JSON file's decoded value, or undefined where it cannot be read or parsed. */
+export function readJSON(host, path) {
+    return readDocument(host, path)?.value;
+}
+/**
+ * The manifest in one directory, decoded, or undefined where none reads as an object. A
+ * manifest this program cannot read declares nothing, the same answer as an absent one:
+ * the package manager owns the refusal of a manifest it rejects.
+ */
+export function manifestAt(host, dir) {
+    const value = readJSON(host, joinPath(dir, MANIFEST));
+    return isRecord(value) ? value : undefined;
+}
+/** Whether one directory holds a manifest file. */
+export function holdsManifest(host, dir) {
+    return host.kindOf(joinPath(dir, MANIFEST)) === "file";
+}

package/dist/src/fs/tree.js

@@ -0,0 +1,88 @@
+import { ancestors, joinPath, resolvePath } from "../paths.js";
+import { LANGUAGE_ROWS } from "../contract/contract.generated.js";
+import { LANGUAGE } from "../product.js";
+import { bytewise } from "../text/compare.js";
+import { globExpression } from "../text/glob.js";
+/** The directories no walk of the tree enters, by the patterns the language's row names. */
+const SKIPPED_DIRECTORIES = LANGUAGE_ROWS[LANGUAGE].skippedDirectories.map(globExpression);
+function skipped(name) {
+    return SKIPPED_DIRECTORIES.some((pattern) => pattern.test(name));
+}
+/** One file's text without its line ending, or undefined where it cannot be read. */
+function lineOf(host, path) {
+    try {
+        return host.readFile(path).replace(/\r?\n$/u, "");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The repository whose working tree holds `dir`: the nearest directory at or above it with a
+ * `.git`. A `.git` file, which a linked worktree or a submodule holds, names the repository's
+ * directory on its `gitdir:` line; that directory's `commondir` file, where it has one, names
+ * the directory shared with the main worktree, which holds `info/exclude`:
+ * https://git-scm.com/docs/gitrepository-layout
+ */
+export function repositoryOf(host, dir) {
+    for (const root of ancestors(dir)) {
+        const dotGit = joinPath(root, ".git");
+        const kind = host.kindOf(dotGit);
+        if (kind === "directory") {
+            return { root, exclude: joinPath(dotGit, "info/exclude") };
+        }
+        if (kind === "file") {
+            const named = /^gitdir: (.+)$/u.exec(lineOf(host, dotGit) ?? "")?.[1];
+            const gitDir = named === undefined ? undefined : resolvePath(root, named);
+            const common = gitDir === undefined ? undefined : lineOf(host, joinPath(gitDir, "commondir"));
+            const shared = gitDir === undefined || common === undefined ? gitDir : resolvePath(gitDir, common);
+            return { root, exclude: shared === undefined ? undefined : joinPath(shared, "info/exclude") };
+        }
+    }
+    return undefined;
+}
+/** The entries of one directory, none where it cannot be read. */
+export function entriesOf(host, dir) {
+    try {
+        return host.readDirectory(dir);
+    }
+    catch {
+        return [];
+    }
+}
+/** The names of the files directly in `dir` whose name `accepts`, in bytewise order. */
+export function filesIn(host, dir, accepts) {
+    return entriesOf(host, dir)
+        .filter((entry) => !entry.directory && accepts(entry.name))
+        .map((entry) => entry.name)
+        .sort(bytewise);
+}
+/** The names of the directories directly in `dir` a walk enters, in bytewise order. */
+export function directoriesIn(host, dir) {
+    return entriesOf(host, dir)
+        .filter((entry) => entry.directory && !skipped(entry.name))
+        .map((entry) => entry.name)
+        .sort(bytewise);
+}
+/**
+ * Every file below `root` whose name `accepts`, by its path relative to `root` in bytewise
+ * order, read in no skipped directory.
+ */
+export function filesBelow(host, root, accepts) {
+    const found = [];
+    const pending = [""];
+    for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
+        for (const entry of entriesOf(host, joinPath(root, dir))) {
+            const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
+            if (!entry.directory) {
+                if (accepts(entry.name)) {
+                    found.push(path);
+                }
+            }
+            else if (!skipped(entry.name)) {
+                pending.push(path);
+            }
+        }
+    }
+    return found.sort(bytewise);
+}