@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.2

package/dist/src/dependencies.js

@@ -6,8 +6,9 @@
  * file a tool loads needs each dependency its strings spell. A package one dependency pulls in for
  * itself is that dependency's need, not the target's.
  */
-import { isCallExpression, isExportDeclaration, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNamespaceExport, isPropertyAccessExpression, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { configurationFiles, declaredIn as declaredBeside, dependenciesNamed, moduleStrings, } from "./configuration-files.js";
+import { isArrayLiteralExpression, isCallExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNamespaceExport, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { automaticTypes } from "./automatic-types.js";
+import { configurationFiles, declaredIn as declaredBeside, dependenciesNamed, moduleStrings, outsideChain, } from "./configuration-files.js";
 import { nodeKey, packageScope } from "./inventory.js";
 import { scriptTokens } from "./manifest.js";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
@@ -18,6 +19,8 @@ const MANIFEST = "package.json";
 const MODULES_DIR = "node_modules";
 const MODULES_SEGMENT = `/${MODULES_DIR}/`;
 const TYPES_SCOPE = "@types/";
+/** A script token naming a JavaScript file by a path no expansion changes. */
+const SCRIPT_FILE = /^[^$`{*?[~]+\.(?:js|mjs|cjs)$/u;
 /** The manifest sections a dependency is declared in, each by the selector its reference spells. */
 const SECTIONS = [
     ["dependencies", "dependency"],
@@ -30,7 +33,7 @@ const PROJECT_OWNER = "";
 export function configurationNeeds(packages) {
     return {
         uses: new Map([[PROJECT_OWNER, new Set(packages)]]),
-        at: new Map([[ANYWHERE, new Set(packages)]]),
+        at: new Map([[ANYWHERE, new Map(packages.map((one) => [one, new Set([PROJECT_OWNER])]))]]),
         unanswered: [],
     };
 }
@@ -99,12 +102,35 @@ function typePackages(name, programPackages) {
     }
     return [typed, named];
 }
+/**
+ * The strings the `extends` member of one compiler configuration file holds, read as the
+ * compiler reads the file, comments and trailing commas allowed; none where it cannot be read.
+ */
+function extendsOf(host, path, parse) {
+    let text;
+    try {
+        text = host.readFile(path);
+    }
+    catch {
+        return [];
+    }
+    const [statement] = parse(path, text).statements;
+    const document = statement !== undefined && isExpressionStatement(statement) ? statement.expression : undefined;
+    if (document === undefined || !isObjectLiteralExpression(document)) {
+        return [];
+    }
+    const value = document.properties
+        .filter(isPropertyAssignment)
+        .findLast((property) => isLiteralText(property.name) && property.name.text === "extends")?.initializer;
+    const entries = value !== undefined && isArrayLiteralExpression(value) ? value.elements : [value];
+    return entries.flatMap((entry) => entry !== undefined && isLiteralText(entry) ? [entry.text] : []);
+}
 /**
  * The packages the compiler configuration of one project names: its type packages,
  * its JSX import source, the helper library it imports, its plugins, and every
  * package a configuration file it extends through is read from.
  */
-function configurationPackages(host, configFile, options, programPackages) {
+function configurationPackages(host, configFile, options, programPackages, parse) {
     const found = new Set();
     const add = (name) => {
         const named = typeof name === "string" ? packageOfSpecifier(name) : undefined;
@@ -139,12 +165,7 @@ function configurationPackages(host, configFile, options, programPackages) {
             continue;
         }
         seen.add(file);
-        const read = readJSON(host, file);
-        const extended = isRecord(read?.value) ? read.value["extends"] : undefined;
-        for (const entry of Array.isArray(extended) ? extended : [extended]) {
-            if (typeof entry !== "string") {
-                continue;
-            }
+        for (const entry of extendsOf(host, file, parse)) {
             if (entry.startsWith(".") || isAbsolutePath(entry)) {
                 const local = resolvePath(dirnamePath(file), entry);
                 pending.push(local.endsWith(".json") ? local : `${local}.json`);
@@ -207,13 +228,19 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
             programPackages.add(named);
         }
     }
-    const packages = configurationPackages(host, project.configFile, project.program.getCompilerOptions(), programPackages);
+    const options = project.program.getCompilerOptions();
+    const packages = configurationPackages(host, project.configFile, options, programPackages, parse);
+    const automatic = automaticTypes(host, project.configFile, options, parse);
     const uses = new Map();
     const at = new Map();
     const use = (owners, named, path) => {
         for (const one of named) {
-            at.set(path, (at.get(path) ?? new Set()).add(one));
+            const inFile = at.get(path) ?? new Map();
+            at.set(path, inFile);
+            const holders = inFile.get(one) ?? new Set();
+            inFile.set(one, holders);
             for (const owner of owners) {
+                holders.add(owner);
                 let set = uses.get(owner);
                 if (set === undefined) {
                     set = new Set();
@@ -229,7 +256,7 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
         const inFile = (owners, named) => {
             use(owners, named, file.fileName);
         };
-        if (fileNeeds(project, held, file, programPackages, inFile)) {
+        if (fileNeeds(project, held, file, { programPackages, automatic }, inFile)) {
             unanswered.push(file.fileName);
         }
     }
@@ -243,7 +270,8 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
         }
         return names;
     };
-    const configuration = configurationFiles(host, targetRoot, sourceFilesOf(project, targetRoot), parse);
+    const files = sourceFilesOf(project, targetRoot);
+    const configuration = configurationFiles(host, targetRoot, files, parse);
     for (const { file, manifestDir } of configuration.modules) {
         const names = declaredAt(joinPath(manifestDir, MANIFEST));
         for (const { node, text } of moduleStrings(file)) {
@@ -258,7 +286,8 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
             }
         }
     }
-    for (const { file, manifestDirs } of configuration.outside) {
+    const ranFiles = outsideChain(host, targetRoot, files, parse, scriptRunFiles(host, targetRoot, files));
+    for (const { file, manifestDirs } of [...configuration.outside, ...ranFiles]) {
         for (const manifestDir of manifestDirs) {
             const names = declaredAt(joinPath(manifestDir, "package.json"));
             for (const { text } of moduleStrings(file)) {
@@ -268,6 +297,48 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
     }
     return { uses, at, unanswered };
 }
+/**
+ * The JavaScript files no program holds that a script of a manifest at or above one of the
+ * project's files runs, each with the directory of that manifest, and those a workflow
+ * step or git hook runs, with the target root's: a token naming such a file below the
+ * target root and in no `node_modules`, read against the manifest's directory.
+ */
+function scriptRunFiles(host, targetRoot, files) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    const dirs = new Set([root]);
+    for (const name of files.byName.keys()) {
+        for (let dir = dirnamePath(name); !dirs.has(dir); dir = dirnamePath(dir)) {
+            if (relativePath(root, dir) === undefined) {
+                break;
+            }
+            dirs.add(dir);
+        }
+    }
+    const tokens = new Map([
+        [root, new Set(workflowTokens(host, root))],
+    ]);
+    for (const dir of dirs) {
+        const read = readJSON(host, joinPath(dir, MANIFEST));
+        if (read !== undefined && isRecord(read.value)) {
+            const own = scriptTokensOf(read.value);
+            tokens.set(dir, dir === root ? new Set([...own, ...(tokens.get(root) ?? [])]) : own);
+        }
+    }
+    const found = [];
+    for (const [manifestDir, held] of tokens) {
+        for (const token of held) {
+            const path = SCRIPT_FILE.test(token) ? resolvePath(manifestDir, token) : undefined;
+            const below = path === undefined ? undefined : relativePath(root, path);
+            if (path !== undefined &&
+                below?.split("/").includes(MODULES_DIR) === false &&
+                !files.byName.has(path) &&
+                host.kindOf(path) === "file") {
+                found.push({ path, manifestDir });
+            }
+        }
+    }
+    return found;
+}
 /** The declarations of the inventory a use written at one node belongs to. */
 function ownersOf(file, held, node) {
     const parent = node.parent;
@@ -291,8 +362,27 @@ function ownersOf(file, held, node) {
     }
     return [PROJECT_OWNER];
 }
-/** Records the needs of one file, and answers whether a specifier of it went unanswered. */
-function fileNeeds(project, held, file, programPackages, use) {
+/**
+ * Whether one identifier stands for a value or type of the scope it is written in, rather
+ * than naming a member, a property or a label.
+ */
+function isScopeName(node) {
+    const parent = node.parent;
+    if (parent === undefined || isShorthandPropertyAssignment(parent)) {
+        return true;
+    }
+    const named = parent;
+    return (named.name !== node &&
+        (parent.kind !== SyntaxKind.QualifiedName || named.right !== node) &&
+        named.propertyName !== node &&
+        named.label !== node);
+}
+/**
+ * Records the needs of one file, and answers whether a specifier of it went unanswered. A
+ * module specifier or a name of the file's scope that resolves to nothing, and that an
+ * automatically included type package declares, uses that package.
+ */
+function fileNeeds(project, held, file, { programPackages, automatic }, use) {
     const specifiers = [...file.imports, ...file.moduleAugmentations].filter(isLiteralText);
     const bindings = [];
     const bound = new Set();
@@ -309,16 +399,22 @@ function fileNeeds(project, held, file, programPackages, use) {
     }
     const names = new Set(bindings.map(({ node }) => node.text));
     const candidates = [];
+    const globals = [];
     const visit = (node) => {
-        if (isIdentifier(node) && names.has(node.text) && !bound.has(node)) {
-            candidates.push(node);
+        if (isIdentifier(node) && !bound.has(node)) {
+            if (names.has(node.text)) {
+                candidates.push(node);
+            }
+            else if (automatic.globals.has(node.text) && isScopeName(node)) {
+                globals.push(node);
+            }
         }
         node.forEachChild(visit);
     };
-    if (names.size > 0) {
+    if (names.size > 0 || automatic.globals.size > 0) {
         visit(file);
     }
-    const asked = [...specifiers, ...bindings.map(({ node }) => node), ...candidates];
+    const asked = [...specifiers, ...bindings.map(({ node }) => node), ...candidates, ...globals];
     const handles = asked.map((node) => project.handle(node));
     const resolved = project.symbolsAt(handles);
     const packagesOf = new Map();
@@ -329,6 +425,9 @@ function fileNeeds(project, held, file, programPackages, use) {
             named.add(byName);
         }
         const symbol = resolved[index];
+        if (symbol === undefined) {
+            automatic.modules.get(specifier.text)?.forEach((one) => named.add(one));
+        }
         for (const declaration of typeof symbol === "object" ? symbol.declarations : []) {
             const byPath = packageOfPath(declaration.path);
             if (byPath !== undefined) {
@@ -364,7 +463,7 @@ function fileNeeds(project, held, file, programPackages, use) {
         let symbol = resolved[offset + index];
         const parent = node.parent;
         if (parent !== undefined && isShorthandPropertyAssignment(parent) && parent.name === node) {
-            symbol = project.shorthandValueAt(project.handle(node));
+            symbol = project.shorthandValueAt(project.handle(parent));
         }
         const named = symbol === UNANSWERED || (unresolvedNames.has(node.text) && symbol === undefined)
             ? byName.get(node.text)
@@ -376,6 +475,13 @@ function fileNeeds(project, held, file, programPackages, use) {
             use(ownersOf(file, held, node), named);
         }
     });
+    const unresolvedAt = offset + candidates.length;
+    globals.forEach((node, index) => {
+        const symbol = resolved[unresolvedAt + index];
+        if (symbol === undefined || symbol === UNANSWERED) {
+            use(ownersOf(file, held, node), automatic.globals.get(node.text) ?? []);
+        }
+    });
     for (const reference of file.typeReferenceDirectives) {
         use(ownersOf(file, held, file), typePackages(reference.fileName, programPackages));
     }
@@ -567,6 +673,18 @@ function manifestDir(dependency) {
     const dir = dirnamePath(dependency.position.path);
     return dir === "." ? "" : dir;
 }
+/**
+ * The declarations of one name a use written at `below` needs: those of the nearest
+ * manifest at or above it that declares the name, or every one for a use no file holds.
+ */
+function nearestDeclaring(declarations, below) {
+    if (below === undefined) {
+        return declarations;
+    }
+    const enclosing = declarations.filter((dependency) => isInside(below, manifestDir(dependency)));
+    const nearest = Math.max(-1, ...enclosing.map((dependency) => manifestDir(dependency).length));
+    return enclosing.filter((dependency) => manifestDir(dependency).length === nearest);
+}
 /**
  * Adds to `needed` each declared dependency that the installed manifest of a needed or
  * run declared dependency names as a peer, until no further one joins: the declaration of
@@ -646,6 +764,8 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
     // A declaration several projects compile is one user, and a use any project makes is
     // a use, so the uses are merged by declaration before anything is counted.
     const needed = new Set();
+    const live = new Set();
+    const holders = new Map();
     const byName = new Map();
     for (const dependency of declared) {
         byName.set(dependency.name, [...(byName.get(dependency.name) ?? []), dependency]);
@@ -656,7 +776,10 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
         // or above its file declares, and what the configuration needs is never deleted.
         const unanswered = project.unanswered.flatMap((file) => relativePath(root, file) ?? []);
         const unknownDeclared = declared.filter((dependency) => unanswered.some((file) => isInside(file, manifestDir(dependency))));
-        unknownDeclared.forEach((dependency) => needed.add(declarationKey(dependency)));
+        for (const dependency of unknownDeclared) {
+            needed.add(declarationKey(dependency));
+            live.add(declarationKey(dependency));
+        }
         const unknown = unknownDeclared.map((dependency) => dependency.name);
         const held = unknown.length === 0 ? [] : [[PROJECT_OWNER, new Set(unknown)]];
         for (const [id, used] of [...project.uses, ...held]) {
@@ -666,16 +789,32 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
         }
         for (const [path, named] of project.at) {
             const below = path === ANYWHERE ? undefined : relativePath(root, path);
-            for (const one of named) {
-                for (const dependency of byName.get(one) ?? []) {
-                    if (below === undefined || isInside(below, manifestDir(dependency))) {
-                        needed.add(declarationKey(dependency));
+            for (const [one, owners] of named) {
+                // An import none of whose bindings is used is no evidence about the code using it.
+                const unheld = owners.size === 0;
+                for (const dependency of nearestDeclaring(byName.get(one) ?? [], below)) {
+                    const key = declarationKey(dependency);
+                    needed.add(key);
+                    if (unheld) {
+                        live.add(key);
+                    }
+                    else {
+                        const held = holders.get(key) ?? new Set();
+                        owners.forEach((owner) => held.add(owner));
+                        holders.set(key, held);
                     }
                 }
             }
         }
     }
     addNeededPeers(declared, peers, needed, ran);
+    addNeededPeers(declared, peers, live, ran);
+    const heldBy = new Map();
+    for (const [key, held] of holders) {
+        if (!live.has(key) && !ran.has(key)) {
+            heldBy.set(key, [...held].sort((a, b) => (a < b ? -1 : 1)));
+        }
+    }
     const users = new Map();
     for (const used of uses.values()) {
         used.forEach((one) => users.set(one, (users.get(one) ?? 0) + 1));
@@ -688,5 +827,21 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
             lastUses.set(id, sole.sort((a, b) => (a < b ? -1 : 1)));
         }
     }
-    return { declared, needed, ran, unbuilt, lastUses };
+    const owners = new Map();
+    for (const [owner, used] of uses) {
+        for (const one of used) {
+            if (names.has(one)) {
+                owners.set(one, (owners.get(one) ?? new Set()).add(owner));
+            }
+        }
+    }
+    const fileLastUses = new Map();
+    for (const [one, held] of [...owners].sort(([a], [b]) => (a < b ? -1 : 1))) {
+        const paths = new Set([...held].map((owner) => owner.replace(/:\d+:\d+$/u, "")));
+        const [path] = paths;
+        if (paths.size === 1 && path !== undefined && path !== PROJECT_OWNER) {
+            fileLastUses.set(path, [...(fileLastUses.get(path) ?? []), one]);
+        }
+    }
+    return { declared, needed, ran, unbuilt, lastUses, fileLastUses, heldBy };
 }

package/dist/src/discover.js

@@ -1,6 +1,8 @@
 import { DiagnosticCategory } from "@typescript/native/sync";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { baseUrlPaths } from "./base-url.js";
+import { dirnamePath, isAbsolutePath, 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. */
@@ -62,10 +64,17 @@ export function diagnosticErrors(sets) {
 }
 /**
  * The codes of a type library and a lib the configuration names that the compiler
- * cannot find, which it reports while it gathers the program's files:
- * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/compiler/processingDiagnostic.go
+ * cannot find, which it reports while it gathers the program's files,
+ * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/compiler/processingDiagnostic.go,
+ * and {@link MISSING_GLOBAL_TYPE}, which the checker reports.
  */
-const UNFOUND_LIBRARY = new Set([2688, 2726, 2727]);
+const UNFOUND_LIBRARY = new Set([2318, 2688, 2726, 2727]);
+/**
+ * The code of a global type the checker finds in no library the program holds. The checker
+ * types every use of one against nothing and places no error in the file, so the analysis
+ * skips each file of such a project whole.
+ */
+export const MISSING_GLOBAL_TYPE = 2318;
 /** The errors one open project carries, each located in the file it names. */
 export function projectErrors(sets) {
     // The compiler numbers its semantic messages from 2000 and its option messages from
@@ -215,19 +224,101 @@ export function consumerProjects(engine, host, root) {
 function derivedId(targetRoot, configFile) {
     return relativePath(targetRoot, configFile) ?? configFile;
 }
+/**
+ * The code of a configuration whose `extends` chain returns to a configuration it already
+ * passed. The parse reports it and returns, and a snapshot opened from it never answers:
+ * https://github.com/microsoft/TypeScript/issues/64754
+ */
+const CIRCULAR_EXTENDS = 18000;
+/** The configuration files one parsed configuration's own `extends` names by path. */
+function extendedPaths(parsed, configFile) {
+    const { raw } = parsed;
+    const named = typeof raw === "object" && raw !== null ? Reflect.get(raw, "extends") : [];
+    return (Array.isArray(named) ? named : [named])
+        .filter((one) => typeof one === "string")
+        .filter((one) => one.startsWith("./") || one.startsWith("../") || isAbsolutePath(one))
+        .map((one) => resolvePath(dirnamePath(configFile), one));
+}
+/**
+ * The `extends` chain from `configFile` to the first configuration it reaches twice, each
+ * link by path, or undefined where no chain written by path returns.
+ */
+function extendsCycle(engine, configFile, parsed) {
+    const walk = (chain, at) => {
+        for (const next of extendedPaths(at, chain.at(-1) ?? configFile)) {
+            if (chain.includes(next)) {
+                return [...chain, next];
+            }
+            let read;
+            try {
+                read = engine.parseConfigFile(next);
+            }
+            catch {
+                continue;
+            }
+            const cycle = walk([...chain, next], read);
+            if (cycle !== undefined) {
+                return cycle;
+            }
+        }
+        return undefined;
+    };
+    return walk([configFile], parsed);
+}
+/** The configuration files one parsed configuration's `references` name. */
+function referencesOf(parsed) {
+    // The parse answers a directory reference as the directory; the compiler reads a
+    // path not ending `.json` as its `tsconfig.json`:
+    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/core/projectreference.go#L18
+    return (parsed.projectReferences ?? []).map(({ path }) => path.endsWith(".json") ? path : joinPath(path, "tsconfig.json"));
+}
+/** Why one parsed configuration's own `extends` chain cannot be opened, where it is circular. */
+function circularity(engine, configFile, parsed) {
+    const chain = extendsCycle(engine, configFile, parsed);
+    if (chain === undefined && !parsed.errors.some(({ code }) => code === CIRCULAR_EXTENDS)) {
+        return undefined;
+    }
+    return `TS${String(CIRCULAR_EXTENDS)}: Circularity detected while resolving configuration: ${(chain ?? [configFile]).join(" -> ")}`;
+}
+/**
+ * Why a configuration the `references` reach, transitively, cannot be opened, where one's
+ * `extends` chain is circular: the compiler opens every referenced project with the one
+ * that references it.
+ */
+function referencedCircularity(engine, references, visited) {
+    for (const reference of references) {
+        if (visited.has(reference)) {
+            continue;
+        }
+        visited.add(reference);
+        let parsed;
+        try {
+            parsed = engine.parseConfigFile(reference);
+        }
+        catch {
+            continue;
+        }
+        const reason = circularity(engine, reference, parsed) ??
+            referencedCircularity(engine, referencesOf(parsed), visited);
+        if (reason !== undefined) {
+            return reason;
+        }
+    }
+    return undefined;
+}
 /**
  * The configuration files one configuration's `references` name, or why the compiler
- * cannot read the configuration.
+ * cannot read the configuration: it throws, or its `extends` chain or that of a
+ * configuration it references is circular, which the analysis refuses before any
+ * snapshot is asked to open it.
  */
 function readConfiguration(engine, configFile) {
     try {
         const parsed = engine.parseConfigFile(configFile);
-        // The parse answers a directory reference as the directory; the compiler reads a
-        // path not ending `.json` as its `tsconfig.json`:
-        // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/core/projectreference.go#L18
-        return {
-            references: (parsed.projectReferences ?? []).map(({ path }) => path.endsWith(".json") ? path : joinPath(path, "tsconfig.json")),
-        };
+        const references = referencesOf(parsed);
+        const reason = circularity(engine, configFile, parsed) ??
+            referencedCircularity(engine, references, new Set([configFile]));
+        return reason === undefined ? { references } : { reason };
     }
     catch (error) {
         return { reason: error instanceof Error ? error.message : String(error) };
@@ -345,3 +436,33 @@ export function discoverProjects(engine, host, scope, configurations = []) {
     }
     return derivedProjects(engine, host, scope);
 }
+/**
+ * How the snapshot reads each configuration of `configFiles` that sets `baseUrl` and
+ * `programs` does not already describe: a configuration only the snapshot holds, which
+ * extends it and states the `paths` {@link baseUrlPaths} gives, so its imports resolve as
+ * the compilers before version 7 resolve them. A configuration the compiler cannot read is
+ * left for its project to refuse.
+ */
+export function withBaseUrlPaths(engine, host, configFiles, programs) {
+    const found = new Map(programs);
+    for (const configFile of configFiles) {
+        if (found.has(configFile)) {
+            continue;
+        }
+        let paths;
+        try {
+            paths = baseUrlPaths(engine.parseConfigFile(configFile).options);
+        }
+        catch {
+            continue;
+        }
+        if (paths !== undefined) {
+            found.set(configFile, {
+                kind: "configuration",
+                file: writtenPath(host, configFile),
+                text: `${JSON.stringify({ extends: configFile, compilerOptions: { paths } }, null, 2)}\n`,
+            });
+        }
+    }
+    return found;
+}

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

@@ -43,7 +43,6 @@ const UNREAD_TOOLS = [
     "cypress",
     "danger",
     "dependency-cruiser",
-    "docusaurus",
     "dotenv",
     "drizzle",
     "electron-vite",
@@ -97,14 +96,12 @@ const UNREAD_TOOLS = [
     "nuxtjs-i18n",
     "nx",
     "nyc",
-    "oclif",
     "openapi-ts",
     "openclaw",
     "orval",
     "oxfmt",
     "oxlint",
     "panda-css",
-    "parcel",
     "payload",
     "pino",
     "playwright-ct",
@@ -149,7 +146,6 @@ const UNREAD_TOOLS = [
     "swc",
     "syncpack",
     "tailwind",
-    "tanstack-router",
     "taskfile",
     "tauri",
     "temporal",
@@ -193,18 +189,19 @@ const UNREAD_TOOLS = [
 ];
 /** The conventions declined for a tool some of whose conventions are entered. */
 const PARTLY_ENTERED = [
+    {
+        tool: "docusaurus",
+        convention: "a page or theme directory a plugin's configuration moves, and the docs",
+        reason: "The convention row reads src/pages and src/theme only, and a document's imports are " +
+            "read from every Markdown and MDX file, so a module only a moved directory holds is " +
+            "reported as never imported unless ts.entry_files names it.",
+    },
     {
         tool: "eslint",
         convention: "a legacy configuration written in YAML or in JSON with comments",
         reason: "Only a configuration module and a strict JSON configuration file are read, so a " +
             "dependency only such a file names is reported as unused.",
     },
-    {
-        tool: "eslint",
-        convention: "a plugin or shareable configuration named without its package's prefix",
-        reason: "A string uses a dependency only where it spells the dependency's name, so a " +
-            "dependency only a shortened name loads is reported as unused.",
-    },
     {
         tool: "playwright",
         convention: "a testMatch written as a regular expression",