@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.3

package/dist/src/analysis.js

@@ -43,7 +43,10 @@ import { references, testFileRulesOf } from "./references.js";
 import { roots, unmatchedEverywhere, } from "./roots.js";
 import { serializationContract } from "./serialization-contract.js";
 import { outsideTestReferences, testFilesAt } from "./outside-tests.js";
+import { mergedGlobalInterfaces } from "./augmentations.js";
+import { unseenLoadsOf } from "./unseen-loads.js";
 import { joinedTestFiles, withJoinedTests } from "./test-joins.js";
+import { GLOBALS_RUNNER, namesTestGlobals, withTestGlobals } from "./test-globals.js";
 import { supportReferences, testSupportFiles } from "./test-support.js";
 import { diagnosticsOf, ownedAs, runSession, } from "./session.js";
 import { accessorsOf, storesOf } from "./stores.js";
@@ -195,7 +198,7 @@ function readProjects(engine, host, scope, config, stage) {
     const joins = discovered.derived
         ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
         : new Map();
-    const programs = withBaseUrlPaths(engine, host, [...discovered.configFiles, ...consumerOf.keys()], workspace?.programs ?? new Map());
+    const programs = withTestGlobals(engine, host, parse, discovered.configFiles, withBaseUrlPaths(engine, host, [...discovered.configFiles, ...consumerOf.keys()], workspace?.programs ?? new Map()));
     const session = runSession(engine, [...discovered.configFiles, ...consumerOf.keys()], (opened) => {
         const consumer = consumerOf.get(opened.configFile);
         const setup = consumer === undefined ? workspace?.unbuildable(opened.configFile) : undefined;
@@ -499,6 +502,9 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                 : { generated: projectRead.generated }),
         }, detectors, disabled);
         const components = project.ownSourceFiles().filter(isComponentFile);
+        const injected = project.program
+            .getSourceFileNames()
+            .some((name) => name.endsWith(`/node_modules/${GLOBALS_RUNNER}/globals.d.ts`));
         const pathOf = (file) => relativePath(targetRoot, file.fileName) ?? file.fileName;
         return {
             projectRead,
@@ -506,11 +512,22 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             testFiles: resolved.testFilePaths,
             evidence,
             componentFiles: components.map(pathOf),
+            augmented: mergedGlobalInterfaces(project, projectRead.held, sourceFilesOf(project, targetRoot)).map((id) => ({ id, kind: "global-augmentation", source: "" })),
             imports: new Map(project.ownSourceFiles().flatMap((file) => {
                 const path = relativePath(targetRoot, file.fileName);
-                return path === undefined
-                    ? []
-                    : [[path, file.imports.filter(isStringLiteralLikeNode).map((one) => one.text)]];
+                if (path === undefined) {
+                    return [];
+                }
+                const specifiers = file.imports.filter(isStringLiteralLikeNode).map((one) => one.text);
+                // A file calling the globals a program declares is written for their runner.
+                return [
+                    [
+                        path,
+                        injected && namesTestGlobals(project, file)
+                            ? [...specifiers, GLOBALS_RUNNER]
+                            : specifiers,
+                    ],
+                ];
             })),
             componentWarnings: components.flatMap((file) => readComponent(file.originalText, extensionOf(file.fileName)).warnings.map((warning) => ({
                 path: pathOf(file),
@@ -549,7 +566,9 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
             references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
-            roots: projectRead.rooted.liveUnderReachability,
+            // The augmentations are rooted after test support is read: an outside declaration
+            // naming one calls nothing of its file.
+            roots: [...projectRead.rooted.liveUnderReachability, ...one.augmented],
             testFiles: [...one.testFiles, ...supportFiles],
             ...(supportFiles.length === 0 ? {} : { supportFiles }),
             ...(testUsedFiles.length === 0 ? {} : { testUsedFiles }),
@@ -761,6 +780,7 @@ export function readEmitterRun(engine, host, scope, config, mode, detectors) {
         directives: inlineDirectives(project, read.held, targetRoot).filter((directive) => !read.referenceOnly.includes(directive.site.path)),
         declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
         parts: projectParts(project, read.held, references, targetRoot),
+        unseenLoads: unseenLoadsOf(project, read.configuration, targetRoot, testFiles),
     }));
     // Whether a declaration carries the marker decides its code, so one whose marker went
     // unread is reported by nothing.
@@ -836,6 +856,7 @@ export function emitterInputOver(host, scope, config, read, input, selfCheck) {
             heldByInclusion: new Set(projects.flatMap((one) => one.extra.heldByInclusion)),
             generated: new Set(projects.flatMap((one) => one.extra.generated)),
             inOperands: new Set(projects.flatMap((one) => one.extra.inOperands)),
+            unseenLoads: projects.flatMap((one) => one.extra.unseenLoads),
         },
         boundary: {
             consumers: {
@@ -886,6 +907,7 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
             librariesUnfound: read.librariesUnfound,
             conventionsApplied: read.conventionsApplied,
             unmappedEntries: unmappedEverywhere(read.projects),
+            unseenLoads: read.projects.flatMap((one) => one.extra.unseenLoads),
         },
         configured: read.projects.map((one) => one.configured),
         symbols,

package/dist/src/augmentations.js

@@ -6,6 +6,8 @@
  * name, which the language or a library types values by where the target never names it,
  * as `import.meta` or `process.env`, so a use of its member is a use of it.
  */
+import { isInterfaceDeclaration, isModuleBlock, isModuleDeclaration, } from "@typescript/native/ast";
+import { nodeKey } from "./inventory.js";
 import { referenceKey } from "./matrix.js";
 /** Whether one declaration is a `declare global` block: a module-level namespace named `global`. */
 function isGlobalBlock(symbol, held, files) {
@@ -54,6 +56,66 @@ export function ambientGlobalInterfaces(held, interfaces, scripts) {
         ? []
         : interfaces.filter((id) => held.ambient.has(id) && holders(id).global);
 }
+/**
+ * Each ambient global interface of the project's own files that merges into an interface
+ * declared outside them, with every interface, namespace and block between it and the
+ * global scope: the outside declaration names it wherever a value is typed by it. Where
+ * every outside declaration is a package's, not the compiler's library, and declares no
+ * member, each member it declares as well: such an interface is a slot the package reads
+ * by type, as `keyof` does, in declarations the analysis does not walk.
+ */
+export function mergedGlobalInterfaces(project, held, files) {
+    const scripts = new Set();
+    const names = new Map();
+    for (const file of files.byName.values()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId !== undefined && file.externalModuleIndicator === undefined) {
+            scripts.add(fileId);
+        }
+        const visit = (node) => {
+            if (isInterfaceDeclaration(node)) {
+                const id = held.declarations.get(nodeKey(file, node));
+                if (id !== undefined) {
+                    names.set(id, node.name);
+                }
+            }
+            else if (isModuleDeclaration(node) || isModuleBlock(node)) {
+                node.forEachChild(visit);
+            }
+        };
+        file.forEachChild(visit);
+    }
+    const global = new Set(ambientGlobalInterfaces(held, [...names.keys()], scripts));
+    const asked = [...names].filter(([id]) => global.has(id));
+    if (asked.length === 0) {
+        return [];
+    }
+    const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
+    const holders = holdersOf(held, scripts);
+    const empty = (handle) => {
+        if (project.program.getSourceFileMetadata(handle.path)?.isDefaultLibrary === true) {
+            return false;
+        }
+        const node = project.declarationAt(handle)?.node;
+        return node !== undefined && isInterfaceDeclaration(node) && node.members.length === 0;
+    };
+    return [
+        ...new Set(asked.flatMap(([id], at) => {
+            const symbol = answers[at];
+            if (typeof symbol !== "object") {
+                return [];
+            }
+            const outside = symbol.declarations.filter((handle) => !files.byName.has(handle.path));
+            if (outside.length === 0) {
+                return [];
+            }
+            const members = outside.every(empty)
+                ? held.symbols.filter((one) => one.parent === id).map((one) => one.id)
+                : [];
+            return [id, ...(holders?.(id).ids ?? []), ...members];
+        })),
+    ];
+}
 /**
  * For each reference to a declaration an augmentation block, or the global scope of a
  * file in `scripts` (the files that are no module), holds, a read at the same place of

package/dist/src/build-scripts.js

@@ -0,0 +1,437 @@
+/**
+ * The files a bundler's JavaScript API builds from, read from the build scripts a
+ * manifest's scripts run: the strings an options object passes as the bundler's entries.
+ * 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 { filesNamedBy } from "./configuration-files.js";
+import { globExpression } from "./glob.js";
+import { scriptTokens } from "./manifest.js";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
+/**
+ * The bundlers whose build call names its entries: esbuild resolves `entryPoints` against
+ * `absWorkingDir` (https://esbuild.github.io/api/#working-directory), webpack `entry`
+ * against `context` (https://webpack.js.org/configuration/entry-context/), and Rollup
+ * `input` against the working directory, each the manifest's directory when its script runs.
+ */
+const BUNDLERS = [
+    {
+        module: "esbuild",
+        calls: ["build", "buildSync", "context"],
+        option: "entryPoints",
+        base: "absWorkingDir",
+        paths: true,
+    },
+    { module: "webpack", calls: ["default"], option: "entry", base: "context", paths: false },
+    { 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;
+}
+/** Whether one call is `require(<module>)`. */
+function requires(node, module) {
+    const at = unwrapped(node);
+    return (isCallExpression(at) &&
+        isIdentifier(at.expression) &&
+        at.expression.text === "require" &&
+        at.arguments.length === 1 &&
+        at.arguments[0] !== undefined &&
+        literalOf(at.arguments[0]) === module);
+}
+function bindingsOf(file, api) {
+    const functions = new Set();
+    const modules = new Set();
+    const building = (name) => api.calls.includes(name);
+    for (const statement of file.statements) {
+        if (isImportDeclaration(statement)) {
+            if (literalOf(statement.moduleSpecifier) !== api.module) {
+                continue;
+            }
+            const clause = statement.importClause;
+            if (clause?.name !== undefined) {
+                (building("default") ? functions : modules).add(clause.name.text);
+            }
+            const named = clause?.namedBindings;
+            if (named !== undefined && isNamespaceImport(named)) {
+                modules.add(named.name.text);
+            }
+            else if (named !== undefined && isNamedImports(named)) {
+                for (const element of named.elements) {
+                    if (building((element.propertyName ?? element.name).text)) {
+                        functions.add(element.name.text);
+                    }
+                }
+            }
+        }
+        else if (isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                const { name, initializer } = declaration;
+                if (initializer === undefined || !requires(initializer, api.module)) {
+                    continue;
+                }
+                if (isIdentifier(name)) {
+                    (building("default") ? functions : modules).add(name.text);
+                }
+                else if (isObjectBindingPattern(name)) {
+                    for (const element of name.elements) {
+                        const local = element.name;
+                        const key = element.propertyName ?? local;
+                        if (key !== undefined &&
+                            local !== undefined &&
+                            isIdentifier(key) &&
+                            isIdentifier(local) &&
+                            building(key.text)) {
+                            functions.add(local.text);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return { functions, modules };
+}
+/** Whether one call's callee is a building function of a bundler the file binds, `shadowed` naming none. */
+function builds(callee, api, bindings, shadowed) {
+    const at = unwrapped(callee);
+    if (isIdentifier(at)) {
+        return bindings.functions.has(at.text) && !shadowed.has(at.text);
+    }
+    if (!isPropertyAccessExpression(at) ||
+        !isIdentifier(at.name) ||
+        !api.calls.includes(at.name.text)) {
+        return false;
+    }
+    const holder = unwrapped(at.expression);
+    return ((isIdentifier(holder) && bindings.modules.has(holder.text) && !shadowed.has(holder.text)) ||
+        requires(holder, api.module));
+}
+/** The top-level `const` initializers one file declares, by name. */
+function constants(file) {
+    const found = new Map();
+    for (const statement of file.statements) {
+        if (isVariableStatement(statement) &&
+            (statement.declarationList.flags & NodeFlags.Const) !== 0) {
+            for (const { name, initializer } of statement.declarationList.declarations) {
+                if (isIdentifier(name) && initializer !== undefined) {
+                    found.set(name.text, initializer);
+                }
+            }
+        }
+    }
+    return found;
+}
+/** The value one object literal writes for one member as `name: value`. */
+function member(object, name) {
+    if (!isObjectLiteralExpression(object)) {
+        return undefined;
+    }
+    for (const property of object.properties) {
+        if (isPropertyAssignment(property) && literalOrName(property.name) === name) {
+            return property.initializer;
+        }
+    }
+    return undefined;
+}
+function literalOrName(node) {
+    return isIdentifier(node) ? node.text : literalOf(node);
+}
+/** Whether one expression is the script's own directory: `__dirname` or `import.meta.dirname`. */
+function isOwnDirectory(node) {
+    const at = unwrapped(node);
+    if (isIdentifier(at)) {
+        return at.text === "__dirname";
+    }
+    return (isPropertyAccessExpression(at) &&
+        isMetaProperty(at.expression) &&
+        isIdentifier(at.name) &&
+        at.name.text === "dirname");
+}
+/**
+ * The path one entry value writes, read against `dir`: a literal, or a `resolve` or
+ * `join` call, of `path` or bound from it, whose first argument is the script's own
+ * directory and whose others are literals.
+ */
+function pathOf(node, dir, scriptDir) {
+    const at = unwrapped(node);
+    const text = literalOf(at);
+    if (text !== undefined) {
+        const request = !text.startsWith("./") && !text.startsWith("../") && !text.startsWith("/");
+        return { path: resolvePath(dir, text), text, request };
+    }
+    if (!isCallExpression(at)) {
+        return undefined;
+    }
+    const callee = unwrapped(at.expression);
+    const name = isPropertyAccessExpression(callee) ? callee.name : callee;
+    if (!isIdentifier(name) || (name.text !== "resolve" && name.text !== "join")) {
+        return undefined;
+    }
+    const [first, ...rest] = at.arguments;
+    const parts = rest.map(literalOf);
+    if (first === undefined || !isOwnDirectory(first) || parts.some((part) => part === undefined)) {
+        return undefined;
+    }
+    const joined = parts.join("/");
+    return { path: resolvePath(scriptDir, joined), text: joined, request: false };
+}
+/** The entry values one entries option writes: a value, an array of them, an object of them. */
+function entryValues(node) {
+    const at = unwrapped(node);
+    if (isArrayLiteralExpression(at)) {
+        return at.elements.flatMap(entryValues);
+    }
+    if (isObjectLiteralExpression(at)) {
+        const imported = member(at, "import") ?? member(at, "in");
+        if (imported !== undefined) {
+            return entryValues(imported);
+        }
+        return at.properties.flatMap((property) => isPropertyAssignment(property) ? entryValues(property.initializer) : []);
+    }
+    return [at];
+}
+/** The own files one entry string names, read as `api` reads it. */
+function entriesNamed(files, api, entry) {
+    if (!api.paths && entry.request) {
+        return [];
+    }
+    if (api.paths && /[*?[{]/u.test(entry.text)) {
+        const expression = globExpression(entry.path);
+        return [...files.byName.values()].filter((file) => expression.test(file.fileName));
+    }
+    const dir = dirnamePath(entry.path);
+    return filesNamedBy(files, dir, entry.path.slice(dir.length + 1));
+}
+/** Whether one node is a function, whose body runs only where something calls it. */
+function isFunction(node) {
+    return (isFunctionDeclaration(node) ||
+        isFunctionExpression(node) ||
+        isArrowFunction(node) ||
+        isMethodDeclaration(node) ||
+        isConstructorDeclaration(node) ||
+        isGetAccessorDeclaration(node) ||
+        isSetAccessorDeclaration(node));
+}
+/** The names one binding name binds: an identifier, or each name a pattern holds. */
+function boundNames(name, into) {
+    if (isIdentifier(name)) {
+        into.add(name.text);
+    }
+    else if (isObjectBindingPattern(name) || isArrayBindingPattern(name)) {
+        name.forEachChild((element) => {
+            const bound = element.name;
+            if (bound !== undefined) {
+                boundNames(bound, into);
+            }
+        });
+    }
+}
+/** The names one function binds of its own: its parameters and the declarations its body holds outside nested functions. */
+function ownBindings(fn) {
+    const found = new Set();
+    const visit = (node) => {
+        if (node !== fn && isFunction(node)) {
+            if (isFunctionDeclaration(node) && node.name !== undefined) {
+                found.add(node.name.text);
+            }
+            return;
+        }
+        if (isVariableDeclaration(node)) {
+            boundNames(node.name, found);
+        }
+        node.forEachChild(visit);
+    };
+    for (const parameter of fn
+        .parameters ?? []) {
+        boundNames(parameter.name, found);
+    }
+    fn.forEachChild(visit);
+    return found;
+}
+/** The functions one file declares under a name: a function declaration, or a variable bound to a function. */
+function namedFunctions(file) {
+    const found = new Map();
+    const add = (name, fn) => {
+        found.set(name, [...(found.get(name) ?? []), fn]);
+    };
+    const visit = (node) => {
+        if (isFunctionDeclaration(node) && node.name !== undefined) {
+            add(node.name.text, node);
+        }
+        else if (isVariableDeclaration(node) &&
+            isIdentifier(node.name) &&
+            node.initializer !== undefined &&
+            isFunction(unwrapped(node.initializer))) {
+            add(node.name.text, unwrapped(node.initializer));
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/**
+ * The calls one build script runs: those of its top level, and those of each function
+ * a call it runs calls or passes on, as a callee, an argument or a function called where
+ * it is written. `shadowed` is the names a function running them binds of its own, which
+ * hide the file's bindings of the same names.
+ */
+function runCalls(file, each) {
+    const named = namedFunctions(file);
+    const ran = new Set();
+    const run = (fn, outer) => {
+        if (ran.has(fn)) {
+            return;
+        }
+        ran.add(fn);
+        const shadowed = new Set([...outer, ...ownBindings(fn)]);
+        fn.forEachChild((child) => {
+            visit(child, shadowed);
+        });
+    };
+    const runs = (node, shadowed) => {
+        const at = unwrapped(node);
+        if (isFunction(at)) {
+            run(at, shadowed);
+        }
+        else if (isIdentifier(at) && !shadowed.has(at.text)) {
+            for (const fn of named.get(at.text) ?? []) {
+                run(fn, new Set());
+            }
+        }
+    };
+    const visit = (node, shadowed) => {
+        if (isFunction(node)) {
+            return;
+        }
+        if (isCallExpression(node) || isNewExpression(node)) {
+            if (isCallExpression(node)) {
+                each(node, shadowed);
+            }
+            runs(node.expression, shadowed);
+            for (const argument of node.arguments ?? []) {
+                runs(argument, shadowed);
+            }
+        }
+        node.forEachChild((child) => {
+            visit(child, shadowed);
+        });
+    };
+    file.forEachChild((child) => {
+        visit(child, new Set());
+    });
+}
+/** The entries every bundler call one build script runs names, read against `dir`. */
+function scriptEntries(file, dir, files) {
+    const found = [];
+    const declared = constants(file);
+    const scriptDir = dirnamePath(file.fileName);
+    const bound = BUNDLERS.map((api) => ({ api, bindings: bindingsOf(file, api) }));
+    runCalls(file, (call, shadowed) => {
+        for (const { api, bindings } of bound) {
+            if (!builds(call.expression, api, bindings, shadowed)) {
+                continue;
+            }
+            const [argument] = call.arguments;
+            let options = argument === undefined ? undefined : unwrapped(argument);
+            if (options !== undefined && isIdentifier(options)) {
+                options = shadowed.has(options.text) ? undefined : declared.get(options.text);
+                options = options === undefined ? undefined : unwrapped(options);
+            }
+            const entries = options === undefined ? undefined : member(options, api.option);
+            const base = options === undefined || api.base === "" ? undefined : member(options, api.base);
+            const against = base === undefined ? { path: dir } : pathOf(base, dir, scriptDir);
+            if (entries === undefined || against === undefined) {
+                continue;
+            }
+            for (const value of entryValues(entries)) {
+                const named = pathOf(value, against.path, scriptDir);
+                if (named === undefined) {
+                    continue;
+                }
+                for (const entry of entriesNamed(files, api, named)) {
+                    found.push({ file: entry, source: named.text });
+                }
+            }
+        }
+    });
+    return found;
+}
+/** 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;
+    if (!isRecord(scripts)) {
+        return [];
+    }
+    const found = new Set();
+    for (const command of Object.values(scripts)) {
+        if (typeof command !== "string") {
+            continue;
+        }
+        for (const token of scriptTokens(command)) {
+            const path = resolvePath(dir, token);
+            if (MODULE_EXTENSION.test(path) &&
+                relativePath(root, path) !== undefined &&
+                !path.split("/").includes("node_modules") &&
+                host.kindOf(path) === "file") {
+                found.add(path);
+            }
+        }
+    }
+    return [...found].sort();
+}
+/**
+ * Every own file of one project a build script names as a bundler's entry: a module a
+ * script of a manifest at or above an own file runs, below the target root, read from
+ * the program where it holds the module and parsed alone otherwise, where a parser is given.
+ */
+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)) {
+            dirs.add(dir);
+        }
+    }
+    const found = [];
+    for (const dir of [...dirs].sort()) {
+        if (host.kindOf(joinPath(dir, MANIFEST)) !== "file") {
+            continue;
+        }
+        for (const path of scriptModules(host, root, dir)) {
+            let script = files.byName.get(path);
+            if (script === undefined && parse !== undefined) {
+                try {
+                    script = parse(path, host.readFile(path));
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (script !== undefined) {
+                found.push(...scriptEntries(script, dir, files));
+            }
+        }
+    }
+    return found;
+}

package/dist/src/conformance-record.js

@@ -4,7 +4,7 @@ export const RECORD = {
     conformance: {
         corpusVersion: "6.0.0",
         result: "pass",
-        digest: "sha256:d65daae4b7c95050c07896b166d0250d233cca71f97de75a6086c1d80fe76232",
+        digest: "sha256:54d3de663b7867df0d50251bf79c3b3d1f023abd178fb477cf0bcd3a01ceb2e5",
     },
     gaps: [],
 };

package/dist/src/convention-rows.js

@@ -10,8 +10,8 @@ const SCRIPT = "{js,jsx,ts,tsx}";
 const MODULE = "{js,mjs,ts,mts}";
 const ANY_MODULE = "{js,mjs,cjs,ts,mts,cts}";
 const VITE_CONFIG = `vite.config.${ANY_MODULE}`;
-/** The legacy configuration files of ESLint that hold JSON or a CommonJS module. */
-const ESLINTRC = [".eslintrc", ".eslintrc.json", ".eslintrc.{js,cjs}"];
+/** The legacy configuration files of ESLint: JSON, YAML or a CommonJS module. */
+const ESLINTRC = [".eslintrc", ".eslintrc.json", ".eslintrc.{yml,yaml}", ".eslintrc.{js,cjs}"];
 const SVELTEKIT_ROUTE_FILES = "+{page,layout,server,page.server,layout.server,error}";
 /** SvelteKit's entries other than its parameter matchers. */
 const SVELTEKIT_ENTRIES = [
@@ -61,6 +61,27 @@ const ANGULAR_PACKAGE_KEYS = [
     "styles",
     "scripts",
 ].map((key) => ({ key, files: ["angular.json"] }));
+/**
+ * The row of a code generator that writes its output below one directory its
+ * configuration's `property` sets, `fallback` where no configuration file sets it, so
+ * every file there is a generated file.
+ */
+function outputDirectoryRow(row) {
+    return {
+        name: row.name,
+        package: row.package,
+        range: row.range,
+        entries: [],
+        generated: ["<output>"],
+        moves: [
+            {
+                id: "output",
+                defaults: [row.fallback],
+                readings: [{ property: row.property, files: row.files }],
+            },
+        ],
+    };
+}
 /**
  * The test runners and the assertion, mock and runner libraries whose import is test
  * evidence beside each runner a row reads test files for. Each applies whether or not a
@@ -149,6 +170,7 @@ export const CONVENTION_ROWS = [
         range: ">=4.0.0 <10.0.0",
         entries: [],
         moves: [],
+        packageKeys: [{ key: "parser", files: ESLINTRC }],
         prefixedNames: [
             { property: "plugins", files: ESLINTRC, prefix: "eslint-plugin" },
             { property: "extends", files: ESLINTRC, prefix: "eslint-plugin", marker: "plugin:" },
@@ -264,6 +286,14 @@ export const CONVENTION_ROWS = [
             { key: "oclif.hooks", directory: false },
         ],
     },
+    outputDirectoryRow({
+        name: "panda",
+        package: "@pandacss/dev",
+        range: ">=0.1.0 <2.0.0",
+        files: [`panda.config.${ANY_MODULE}`],
+        property: "outdir",
+        fallback: "styled-system",
+    }),
     {
         name: "parcel",
         package: "parcel",
@@ -331,6 +361,13 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        name: "react-scripts",
+        package: "react-scripts",
+        range: ">=1.0.0 <6.0.0",
+        entries: [`src/index.${SCRIPT}`, "src/setupProxy.js", `src/setupTests.${SCRIPT}`],
+        moves: [],
+    },
     {
         name: "remix",
         package: "@remix-run/dev",