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

package/dist/bin/mapper-connection.js

@@ -7,6 +7,7 @@
  */
 import { componentModule } from "../src/component-files.js";
 import { extensionOf } from "../src/paths.js";
+import { PRODUCT } from "../src/product.js";
 /** The JSON-RPC code of a method this mapper does not serve. */
 const METHOD_NOT_FOUND = -32601;
 /** The JSON-RPC code of a request whose parameters are not the protocol's. */
@@ -37,7 +38,7 @@ function answer(message) {
     });
     switch (message.method) {
         case "initialize":
-            return reply({ positionEncoding: "utf-16", diagnosticSource: "deadset-ts" });
+            return reply({ positionEncoding: "utf-16", diagnosticSource: PRODUCT });
         case "openProject":
             return reply({});
         case "closeProject":

package/dist/bin/node-host.js

@@ -1,10 +1,11 @@
 import { randomBytes } from "node:crypto";
-import { closeSync, fchmodSync, fsyncSync, mkdtempSync, openSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeSync, } from "node:fs";
+import { closeSync, fchmodSync, fsyncSync, mkdtempSync, openSync, readdirSync, readFileSync, readSync, realpathSync, renameSync, rmSync, statSync, writeSync, } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, extname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { PRODUCT } from "../src/product.js";
 /** The name the manifest of this package declares. */
-const PACKAGE_NAME = "@cplieger/deadset-ts";
+const PACKAGE_NAME = `@cplieger/${PRODUCT}`;
 /** The version the walk found, read once per process. */
 let found;
 /**
@@ -76,9 +77,24 @@ function writeAtomically(path, pieces) {
         throw error;
     }
 }
+/** The text of a file's first `limit` bytes, or of all of it where it holds fewer. */
+function readHead(path, limit) {
+    const bytes = Buffer.alloc(limit);
+    const fd = openSync(path, "r");
+    try {
+        let held = 0;
+        for (let got = -1; got !== 0 && held < limit; held += got) {
+            got = readSync(fd, bytes, held, limit - held, null);
+        }
+        return bytes.toString("utf8", 0, held);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 /** A new directory under the platform's temporary directory. */
 function temporaryDirectory() {
-    const path = mkdtempSync(join(tmpdir(), "deadset-ts-mapper-"));
+    const path = mkdtempSync(join(tmpdir(), `${PRODUCT}-mapper-`));
     return {
         path,
         remove: () => {
@@ -105,7 +121,7 @@ function componentMapperCommand() {
 export function nodeHost() {
     return {
         workingDirectory: () => process.cwd(),
-        readFile: (path) => readFileSync(path, "utf8"),
+        readFile: (path, limit) => limit === undefined ? readFileSync(path, "utf8") : readHead(path, limit),
         readDirectory: (path) => readdirSync(path, { withFileTypes: true }).map((entry) => ({
             name: entry.name,
             directory: entry.isDirectory(),
@@ -115,7 +131,10 @@ export function nodeHost() {
             if (stat === undefined) {
                 return "absent";
             }
-            return stat.isDirectory() ? "directory" : "file";
+            if (stat.isDirectory()) {
+                return "directory";
+            }
+            return stat.isFile() ? "file" : "other";
         },
         realPath: (path) => realpathSync(path),
         analyzerVersion: () => {

package/dist/src/analysis.js

@@ -22,7 +22,6 @@ import { inOperandNames } from "./in-operands.js";
 import { sourceFilesOf } from "./source-files.js";
 import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, writtenRecords, } from "./exempt.js";
 import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
-import { globExpression } from "./glob.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
 import { unmatchedRootFindings } from "./findings/self-check.js";
 import { frameworkLifecycle } from "./framework-lifecycle.js";
@@ -33,9 +32,8 @@ import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
 import { packageEntries, readManifest } from "./manifest.js";
 import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
-import { dirnamePath, extensionOf, joinPath, normalizePath, relativePath, resolvePath, } from "./paths.js";
+import { ancestors, dirnamePath, extensionOf, joinPath, normalizePath, relativePath, resolvePath, } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
-import { LANGUAGE } from "./report.js";
 import { SetupError, setupLine } from "./setup-failure.js";
 import { pathsOf, readErrors, skippedRoots, skippedUnits, } from "./type-errors.js";
 import { reflectiveLookup } from "./reflective-lookup.js";
@@ -55,6 +53,9 @@ import { bindRows, readBaseline, readIgnoreFile } from "./suppress-file.js";
 import { inlineDirectives, inlineSuppressions } from "./suppress-inline.js";
 import { readTemplates, templateField } from "./template-field.js";
 import { ownErrors, workspaceRun } from "./workspace-run.js";
+import { bytewise } from "./text/compare.js";
+import { holdsManifest, inInstalledPackages, MANIFEST, manifestAt } from "./fs/manifest.js";
+import { globExpression } from "./text/glob.js";
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
 /**
@@ -71,21 +72,14 @@ function documentOf(host, provenance, setting, targetRoot) {
     const document = resolvePath(host.workingDirectory(), origin.label);
     return relativePath(resolvePath(host.workingDirectory(), targetRoot), document) ?? "";
 }
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /**
  * The manifests the analysis reads, each once: the target's own, then every workspace
  * member's and every nested package's below the target root.
  */
 function conventionManifests(host, targetRoot, memberDirs, nestedDirs) {
     const found = new Map();
-    if (host.kindOf(joinPath(targetRoot, "package.json")) === "file") {
-        found.set(targetRoot, { dir: targetRoot, path: "package.json" });
+    if (holdsManifest(host, targetRoot)) {
+        found.set(targetRoot, { dir: targetRoot, path: MANIFEST });
     }
     for (const [dirs, nested] of [
         [memberDirs, false],
@@ -109,17 +103,18 @@ function nestedPackageDirs(host, targetRoot, files, known) {
     const seen = new Set();
     const found = [];
     for (const file of files) {
-        for (let dir = dirnamePath(file); dir !== targetRoot && !seen.has(dir) && relativePath(targetRoot, dir) !== undefined; dir = dirnamePath(dir)) {
+        for (const dir of ancestors(dirnamePath(file), targetRoot)) {
+            if (seen.has(dir) || relativePath(targetRoot, dir) === undefined) {
+                break;
+            }
             seen.add(dir);
             const below = relativePath(targetRoot, dir) ?? "";
-            if (!below.split("/").includes("node_modules") &&
-                !known.has(dir) &&
-                host.kindOf(joinPath(dir, "package.json")) === "file") {
+            if (!inInstalledPackages(below) && !known.has(dir) && holdsManifest(host, dir)) {
                 found.push(dir);
             }
         }
     }
-    return found.sort(compare);
+    return found.sort(bytewise);
 }
 /**
  * Reads every project the scope discovers, and each declared consumer's, in one snapshot,
@@ -145,13 +140,13 @@ function readProjects(engine, host, scope, config, stage) {
     // The nested packages are known only once every program is open, and every visit reads
     // the conventions and options they decide, so both are set in the session's first step.
     let nestedDirs = [];
-    let conventions = readConventions(host, parse, [], config.ts.disabledConventions);
+    let conventions = readConventions(host, parse, [], config.ts.disabled_conventions);
     let options;
     const readManifests = (opened) => {
         nestedDirs = nestedPackageDirs(host, normalizePath(absoluteRoot), opened
             .filter((one) => !consumerOf.has(one.configFile))
             .flatMap((one) => [one.configFile, ...one.fileNames()]), new Set(memberDirs));
-        conventions = readConventions(host, parse, conventionManifests(host, absoluteRoot, memberDirs, nestedDirs), config.ts.disabledConventions);
+        conventions = readConventions(host, parse, conventionManifests(host, absoluteRoot, memberDirs, nestedDirs), config.ts.disabled_conventions);
         options = {
             host,
             manifest: workspace?.manifest ?? readManifest(host, targetRoot),
@@ -159,12 +154,12 @@ function readProjects(engine, host, scope, config, stage) {
                 ...(workspace?.entries ?? []),
                 ...packageEntries(host, normalizePath(absoluteRoot), nestedDirs),
             ],
-            patterns: config.rootPatterns,
-            entryFiles: config.ts.entryFiles,
+            patterns: config.roots.patterns,
+            entryFiles: config.ts.entry_files,
             conventions,
-            testFiles: config.ts.testFiles,
+            testFiles: config.ts.test_files,
             parse,
-            publishedAPI: config.targetKind !== "" && kindOf(config.targetKind, LANGUAGE) === "library",
+            publishedAPI: config.target.kind !== undefined && kindOf(config.target.kind) === "library",
             publishedMembers: new Set((workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir)),
             runFiles: new Set(opened.flatMap((one) => one.fileNames().map((name) => resolvePath(host.workingDirectory(), name)))),
         };
@@ -194,7 +189,7 @@ function readProjects(engine, host, scope, config, stage) {
             unbuildable.push(...met);
         }
     };
-    const testPatterns = config.ts.testFiles.map(globExpression);
+    const testPatterns = config.ts.test_files.map(globExpression);
     const joins = discovered.derived
         ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
         : new Map();
@@ -400,8 +395,10 @@ export function runRoots(engine, host, scope, config, provenance) {
             }
         }
     }
-    const ordered = [...merged.values()].sort((a, b) => byPosition(a.position, b.position) || compare(a.kind, b.kind) || compare(a.source, b.source));
-    const unmatched = unmatchedEverywhere(config.rootPatterns, projects.map((answer) => answer.rooted));
+    const ordered = [...merged.values()].sort((a, b) => byPosition(a.position, b.position) ||
+        bytewise(a.kind, b.kind) ||
+        bytewise(a.source, b.source));
+    const unmatched = unmatchedEverywhere(config.roots.patterns, projects.map((answer) => answer.rooted));
     return {
         configurations,
         roots: ordered,
@@ -438,18 +435,9 @@ function testEvidence(host, targetRoot, projects) {
         }
     }
     const manifests = new Map();
-    const manifestAt = (dir) => {
+    const manifestIn = (dir) => {
         if (!manifests.has(dir)) {
-            let value;
-            try {
-                value = JSON.parse(host.readFile(joinPath(dir, "package.json")));
-            }
-            catch {
-                value = undefined;
-            }
-            manifests.set(dir, typeof value === "object" && value !== null && !Array.isArray(value)
-                ? value
-                : undefined);
+            manifests.set(dir, manifestAt(host, dir));
         }
         return manifests.get(dir);
     };
@@ -458,16 +446,14 @@ function testEvidence(host, targetRoot, projects) {
     return {
         imports,
         devDependency: (path, name) => {
-            for (let dir = dirnamePath(joinPath(root, path));; dir = dirnamePath(dir)) {
-                const manifest = manifestAt(dir);
+            for (const dir of ancestors(dirnamePath(joinPath(root, path)), root)) {
+                const manifest = manifestIn(dir);
                 const other = OTHER_SECTIONS.some((one) => declares(manifest?.[one], name));
                 if (declares(manifest?.[DEV_SECTION], name) || other) {
                     return !other;
                 }
-                if (normalizePath(dir) === normalizePath(root) || dirnamePath(dir) === dir) {
-                    return false;
-                }
             }
+            return false;
         },
     };
 }
@@ -481,13 +467,13 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
     const targetRoot = scope.target.path;
     const disabled = disabledClasses(config);
     const templates = disabled.has("template-field")
-        ? { delimiters: config.analysis.templateDelimiters, files: [] }
+        ? { delimiters: config.analysis.template_delimiters, files: [] }
         : readTemplates(host, targetRoot, config.analysis);
     const consumers = scope.consumers.map((consumer) => consumer.path);
     const read = readProjects(engine, host, scope, config, (project, opened) => {
         const projectRead = opened.read();
         const resolved = references(project, projectRead.held, targetRoot, {
-            testFiles: config.ts.testFiles,
+            testFiles: config.ts.test_files,
             testFileNames: projectRead.testFileNames,
         });
         const evidence = evidenceRecords({
@@ -497,7 +483,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             templates,
             ts: config.ts,
             consumers,
-            ...(config.analysis.generatedFiles === "include"
+            ...(config.analysis.generated_files === "include"
                 ? {}
                 : { generated: projectRead.generated }),
         }, detectors, disabled);
@@ -574,8 +560,8 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         const exempt = detected.records;
         const made = supportReferences([...one.references, ...(satisfied?.references ?? [])], support);
         const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
-        const supportFiles = [...support].filter((path) => held.has(path)).sort();
-        const testUsedFiles = [...testUsed].filter((path) => held.has(path)).sort();
+        const supportFiles = [...support].filter((path) => held.has(path)).sort(bytewise);
+        const testUsedFiles = [...testUsed].filter((path) => held.has(path)).sort(bytewise);
         const configured = {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
@@ -774,7 +760,7 @@ function sweptOf(read, input) {
         unanswered: read.unanswered,
         heldByUnanswered: [...held],
         skipped: read.projects.flatMap((one) => one.skipped),
-        componentFiles: [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(compare),
+        componentFiles: [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(bytewise),
     };
 }
 /**
@@ -853,12 +839,7 @@ function judgedMembers(host, targetRoot, read) {
 }
 /** The directory of the nearest `package.json` at or above a file, inside `root`, else `root`. */
 function nearestManifestDir(host, root, file) {
-    for (let dir = dirnamePath(file); relativePath(root, dir) !== undefined; dir = dirnamePath(dir)) {
-        if (host.kindOf(joinPath(dir, "package.json")) === "file") {
-            return dir;
-        }
-    }
-    return root;
+    return ancestors(dirnamePath(file), root).find((dir) => holdsManifest(host, dir)) ?? root;
 }
 /**
  * The input every emitter reads over one sweep of a read run: the facts beside the sweep
@@ -922,7 +903,7 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
                 id: one.configured.configuration,
                 configFile: one.configFile,
             })),
-            testFileRules: testFileRulesOf(config.ts.testFiles, read.projects.flatMap((one) => one.configured.testFiles), read.projects.flatMap((one) => one.configured.supportFiles ?? [])),
+            testFileRules: testFileRulesOf(config.ts.test_files, read.projects.flatMap((one) => one.configured.testFiles), read.projects.flatMap((one) => one.configured.supportFiles ?? [])),
             typeErrorSkips: read.projects.flatMap((one) => one.typeErrorSkips),
             componentWarnings: [
                 ...new Map(read.projects
@@ -952,7 +933,7 @@ function inputsOver(host, scope, config, provenance, mode, read, documents) {
     };
     const facts = {
         refusals: suppressions.refusals,
-        unmatchedRoots: unmatchedEverywhere(config.rootPatterns, read.projects.map((one) => one.extra.rooted)),
+        unmatchedRoots: unmatchedEverywhere(config.roots.patterns, read.projects.map((one) => one.extra.rooted)),
         rootsDocument: documentOf(host, provenance, ROOTS_SETTING, targetRoot),
         unmatchedDeclarations: configuredDeclarations(config)
             .filter((_, at) => !read.projects.some((one) => one.extra.declarationsNamed[at] === true))

package/dist/src/automatic-types.js

@@ -5,7 +5,9 @@
  * declarations, and a use of one resolves to nothing; each such use is a use of the package.
  */
 import { isClassDeclaration, isEnumDeclaration, isExportAssignment, isExportDeclaration, isFunctionDeclaration, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isModuleBlock, isModuleDeclaration, isStringLiteral, isTypeAliasDeclaration, isVariableStatement, SyntaxKind, } from "@typescript/native/ast";
-import { dirnamePath, joinPath, resolvePath } from "./paths.js";
+import { ancestors, dirnamePath, joinPath, resolvePath } from "./paths.js";
+import { entriesOf } from "./fs/tree.js";
+import { manifestAt } from "./fs/manifest.js";
 const TYPE_ROOT = "node_modules/@types";
 const NONE = { globals: new Map(), modules: new Map() };
 /**
@@ -73,19 +75,11 @@ function fileDeclarations(file, globals, modules) {
 }
 /** The entry declaration file of one installed type package's directory. */
 function entryOf(host, dir) {
-    try {
-        const manifest = JSON.parse(host.readFile(joinPath(dir, "package.json")));
-        const named = typeof manifest === "object" && manifest !== null
-            ? (manifest["types"] ??
-                manifest["typings"])
-            : undefined;
-        if (typeof named === "string" && named !== "") {
-            const path = resolvePath(dir, named);
-            return path.endsWith(".ts") ? path : `${path}.d.ts`;
-        }
-    }
-    catch {
-        // A package with no readable manifest is read from its index, as the compiler reads it.
+    const manifest = manifestAt(host, dir);
+    const named = manifest?.["types"] ?? manifest?.["typings"];
+    if (typeof named === "string" && named !== "") {
+        const path = resolvePath(dir, named);
+        return path.endsWith(".ts") ? path : `${path}.d.ts`;
     }
     return joinPath(dir, "index.d.ts");
 }
@@ -146,14 +140,7 @@ export function automaticTypes(host, configFile, options, parse) {
     };
     const read = new Set();
     for (const root of typeRoots(configFile, options)) {
-        let entries;
-        try {
-            entries = host.readDirectory(root);
-        }
-        catch {
-            entries = [];
-        }
-        for (const entry of entries) {
+        for (const entry of entriesOf(host, root)) {
             if (read.has(entry.name) || host.kindOf(joinPath(root, entry.name)) !== "directory") {
                 continue;
             }
@@ -179,11 +166,5 @@ function typeRoots(configFile, options) {
     if (Array.isArray(listed)) {
         return listed.filter((root) => typeof root === "string" && root.endsWith(`/${TYPE_ROOT}`));
     }
-    const roots = [];
-    for (let dir = dirnamePath(configFile);; dir = dirnamePath(dir)) {
-        roots.push(joinPath(dir, TYPE_ROOT));
-        if (dirnamePath(dir) === dir) {
-            return roots;
-        }
-    }
+    return ancestors(dirnamePath(configFile)).map((dir) => joinPath(dir, TYPE_ROOT));
 }

package/dist/src/build-scripts.js

@@ -4,11 +4,15 @@
  * A script is read without running it, so a value that is not written out, a computed
  * path or an options object built at run time among them, names nothing.
  */
-import { isArrayBindingPattern, isArrayLiteralExpression, isArrowFunction, isAsExpression, isCallExpression, isConstructorDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isImportDeclaration, isMetaProperty, isMethodDeclaration, isNamedImports, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isSetAccessorDeclaration, isStringLiteral, isVariableDeclaration, isVariableStatement, NodeFlags, } from "@typescript/native/ast";
+import { isArrayBindingPattern, isArrayLiteralExpression, isArrowFunction, isCallExpression, isConstructorDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isImportDeclaration, isMetaProperty, isMethodDeclaration, isNamedImports, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isSetAccessorDeclaration, isStringLiteral, isVariableDeclaration, isVariableStatement, NodeFlags, } from "@typescript/native/ast";
 import { filesNamedBy } from "./configuration-files.js";
-import { globExpression } from "./glob.js";
-import { scriptTokens } from "./manifest.js";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { ancestors, dirnamePath, relativePath, resolvePath } from "./paths.js";
+import { bytewise } from "./text/compare.js";
+import { isRecord } from "./json-document.js";
+import { unwrapped } from "./unwrap.js";
+import { holdsManifest, inInstalledPackages, manifestAt } from "./fs/manifest.js";
+import { globExpression } from "./text/glob.js";
+import { scriptTokens } from "./text/shell.js";
 /**
  * The bundlers whose build call names its entries: esbuild resolves `entryPoints` against
  * `absWorkingDir` (https://esbuild.github.io/api/#working-directory), webpack `entry`
@@ -27,18 +31,6 @@ const BUNDLERS = [
     { module: "rollup", calls: ["rollup", "watch"], option: "input", base: "", paths: true },
 ];
 const MODULE_EXTENSION = /\.(?:js|mjs|cjs|ts|mts|cts)$/u;
-const MANIFEST = "package.json";
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/** The expression a wrapper that changes no value holds. */
-function unwrapped(node) {
-    let at = node;
-    while (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
-        at = at.expression;
-    }
-    return at;
-}
 function literalOf(node) {
     const at = unwrapped(node);
     return isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at) ? at.text : undefined;
@@ -372,14 +364,7 @@ function scriptEntries(file, dir, files) {
 }
 /** The modules one manifest's scripts run, by absolute path, each below the target root. */
 function scriptModules(host, root, dir) {
-    let manifest;
-    try {
-        manifest = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
-    }
-    catch {
-        return [];
-    }
-    const scripts = isRecord(manifest) ? manifest["scripts"] : undefined;
+    const scripts = manifestAt(host, dir)?.["scripts"];
     if (!isRecord(scripts)) {
         return [];
     }
@@ -392,13 +377,13 @@ function scriptModules(host, root, dir) {
             const path = resolvePath(dir, token);
             if (MODULE_EXTENSION.test(path) &&
                 relativePath(root, path) !== undefined &&
-                !path.split("/").includes("node_modules") &&
+                !inInstalledPackages(path) &&
                 host.kindOf(path) === "file") {
                 found.add(path);
             }
         }
     }
-    return [...found].sort();
+    return [...found].sort(bytewise);
 }
 /**
  * Every own file of one project a build script names as a bundler's entry: a module a
@@ -409,13 +394,16 @@ export function buildScriptEntries(host, targetRoot, files, parse) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const dirs = new Set([root]);
     for (const file of files.byName.values()) {
-        for (let dir = dirnamePath(file.fileName); relativePath(root, dir) !== undefined && !dirs.has(dir); dir = dirnamePath(dir)) {
+        for (const dir of ancestors(dirnamePath(file.fileName), root)) {
+            if (dirs.has(dir)) {
+                break;
+            }
             dirs.add(dir);
         }
     }
     const found = [];
-    for (const dir of [...dirs].sort()) {
-        if (host.kindOf(joinPath(dir, MANIFEST)) !== "file") {
+    for (const dir of [...dirs].sort(bytewise)) {
+        if (!holdsManifest(host, dir)) {
             continue;
         }
         for (const path of scriptModules(host, root, dir)) {

package/dist/src/component-layer.js

@@ -5,9 +5,11 @@
  * member wins over one it extends. The mapper resolves as a package linked into the
  * `node_modules` beside each configuration, to a directory holding only its manifest.
  */
+import { INSTALLED_PACKAGES } from "./fs/manifest.js";
 import { dirnamePath, joinPath } from "./paths.js";
+import { PRODUCT } from "./product.js";
 /** The name the mapper's manifest declares and every configuration's entry names. */
-const MAPPER_PACKAGE = "deadset-ts-component-files";
+const MAPPER_PACKAGE = `${PRODUCT}-component-files`;
 /** The manifest of the mapper's package, which runs `command`. */
 export function mapperManifest(command) {
     return `${JSON.stringify({
@@ -122,7 +124,7 @@ export function componentLayer(host, configFiles, mapper, written = new Map()) {
     for (const configFile of configFiles) {
         files[configFile] = withContentMappers(written.get(configFile) ?? host.readFile(configFile), mappers);
         if (mapper !== undefined) {
-            symlinks[joinPath(dirnamePath(configFile), "node_modules", MAPPER_PACKAGE)] = {
+            symlinks[joinPath(dirnamePath(configFile), INSTALLED_PACKAGES, MAPPER_PACKAGE)] = {
                 target: mapper.packageDirectory,
                 host: true,
             };

package/dist/src/components.js

@@ -4,13 +4,12 @@
  * and every dead declaration that falls with them, being dead only through them.
  */
 import { OUTSIDE } from "./graph.js";
-/** The name every component identifier this analyzer mints starts with. */
-const ANALYZER = "deadset-ts";
+import { PRODUCT } from "./product.js";
 /** The fewest digits a component identifier's number is written with. */
 const ID_DIGITS = 4;
 /** The identifier of the component at one place of the run's order, counted from one. */
 export function componentId(place) {
-    return `${ANALYZER}/c-${String(place).padStart(ID_DIGITS, "0")}`;
+    return `${PRODUCT}/c-${String(place).padStart(ID_DIGITS, "0")}`;
 }
 /** The index of a declaration the component walk has not reached. */
 const UNVISITED = -1;

package/dist/src/config.js

@@ -1,74 +1,18 @@
-import { CONTRACT_VERSION, } from "./contract/contract.generated.js";
+import { SEVERITIES } from "./contract/contract.generated.js";
+import { LANGUAGE } from "./product.js";
 /**
  * The name of the repository configuration at the target root, which is also the
  * document a finding about the configuration names where no document of the
  * target supplied the setting it is about.
  */
 export const REPOSITORY_DOCUMENT = "deadset.json";
-/** The kind a target kind setting gives one language's declarations. */
-export function kindOf(setting, language) {
-    return typeof setting === "string" ? setting : setting[language];
+/** The kind a target kind setting gives this analyzer's declarations. */
+export function kindOf(kind) {
+    return typeof kind === "string" ? kind : kind[LANGUAGE];
 }
-/** The severities ranked, the strongest highest. */
-const SEVERITY_RANK = { allow: 0, warn: 1, deny: 2 };
 /** Whether a finding at one severity fails a run under the failing severity. */
 export function fails(severity, failOn) {
-    return SEVERITY_RANK[severity] >= SEVERITY_RANK[failOn];
-}
-/**
- * The configuration every documented default states. `targetKind` is empty: the
- * field has no default and is never inferred.
- */
-export function defaultConfig() {
-    return {
-        contractVersion: CONTRACT_VERSION,
-        targetKind: "",
-        analysis: {
-            languages: [],
-            minConfidence: "probable",
-            generatedFiles: "exclude",
-            consumerTests: "test",
-            configurations: [],
-            matrixComplete: false,
-            templateDirs: [],
-            templateDelimiters: { left: "{{", right: "}}" },
-        },
-        consumersComplete: false,
-        rootPatterns: [],
-        severity: new Map(),
-        exemptionsDisabled: [],
-        reporters: {
-            formats: ["text"],
-            sort: "position",
-            cascade: "roots",
-            maxFindings: 0,
-            failOn: "deny",
-        },
-        providers: {
-            analyzers: [
-                { shape: "installed", name: "deadset-go", languages: ["go"], command: "deadset-go" },
-                { shape: "installed", name: "deadset-ts", languages: ["ts"], command: "deadset-ts" },
-            ],
-        },
-        ts: {
-            testFiles: [
-                "**/*.test.{ts,tsx,mts,cts}",
-                "**/*.test-d.{ts,tsx,mts,cts}",
-                "**/*.spec-d.{ts,tsx,mts,cts}",
-                "**/*.spec.*",
-                "**/__tests__/**",
-                "**/__mocks__/**",
-                "**/test-d/**",
-            ],
-            entryFiles: [],
-            componentExtensions: [".vue", ".svelte", ".astro"],
-            disabledConventions: [],
-            injectionRegistrations: [],
-            lifecycleContracts: [],
-            serializers: [],
-            rootsComplete: false,
-        },
-    };
+    return SEVERITIES.indexOf(severity) >= SEVERITIES.indexOf(failOn);
 }
 /**
  * Renders the origin as the provenance value the Contract declares: `default`,
@@ -77,23 +21,3 @@ export function defaultConfig() {
 export function renderOrigin(origin) {
     return origin.source === "default" ? "default" : `${origin.source}: ${origin.label}`;
 }
-/**
- * Every refusal configuration resolution makes. Each maps to the usage exit
- * code, and each is thrown rather than returned: a refusal ends the run, and the
- * one caller that turns it into an exit code is the command line.
- */
-export class ConfigError extends Error {
-    /** Which refusal this is. */
-    kind;
-    /**
-     * The key or field the message names, spelled as the document spells it. It is
-     * empty when the refusal names none.
-     */
-    key;
-    constructor(kind, key, message) {
-        super(message);
-        this.name = "ConfigError";
-        this.kind = kind;
-        this.key = key;
-    }
-}