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

package/dist/src/entries/build-scripts.js

@@ -0,0 +1,222 @@
+/**
+ * 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 { isArrowFunction, isCallExpression, isConstructorDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNewExpression, isSetAccessorDeclaration, isVariableDeclaration, } from "@typescript/native/ast";
+import { declarationOf, membersNamed, staticModule } from "./static-module.js";
+import { filesNamedBy } from "./configuration-files.js";
+import { ancestors, dirnamePath, isExplicitPath, relativePath, resolvePath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { unwrapped } from "../unwrap.js";
+import { holdsManifest, inInstalledPackages, manifestAt } from "../fs/manifest.js";
+import { globExpression } from "../text/glob.js";
+import { pathsNamed, readCommands } from "../commands/read.js";
+import { manifestCommands } from "../roots/manifest.js";
+import { extensionOf, MODULE_EXTENSIONS } from "../extensions.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 },
+];
+/** The one value an object writes last for a key, undefined where it writes none or may hide it. */
+function lastMember(object, key) {
+    return membersNamed(object, key)?.at(-1);
+}
+/**
+ * The path one entry value writes, read against `dir`: a literal, or a join of the
+ * script's own directory and literals, read against that directory.
+ */
+function pathOf(value, dir, scriptDir) {
+    if (value.kind === "text") {
+        const { text } = value;
+        const request = !isExplicitPath(text);
+        return { path: resolvePath(dir, text), text, request };
+    }
+    if (value.kind === "directory") {
+        const joined = value.segments.join("/");
+        return { path: resolvePath(scriptDir, joined), text: joined, request: false };
+    }
+    return undefined;
+}
+/** The entry values one entries option writes: a value, an array of them, an object of them. */
+function entryValues(value) {
+    if (value.kind === "array") {
+        return value.elements.flatMap(entryValues);
+    }
+    if (value.kind === "object") {
+        const imported = lastMember(value, "import") ?? lastMember(value, "in");
+        if (imported !== undefined) {
+            return entryValues(imported);
+        }
+        return value.members.flatMap((member) => entryValues(member.value));
+    }
+    return [value];
+}
+/** 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 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, a name read through to the function it declares.
+ */
+function runCalls(file, each) {
+    const ran = new Set();
+    const run = (fn) => {
+        if (!ran.has(fn)) {
+            ran.add(fn);
+            fn.forEachChild(visit);
+        }
+    };
+    const runs = (node) => {
+        const at = unwrapped(node);
+        const declared = isIdentifier(at) ? declarationOf(at) : undefined;
+        const fn = declared !== undefined && isVariableDeclaration(declared) && declared.initializer
+            ? unwrapped(declared.initializer)
+            : (declared ?? at);
+        if (isFunction(fn)) {
+            run(fn);
+        }
+    };
+    const visit = (node) => {
+        if (isFunction(node)) {
+            return;
+        }
+        if (isCallExpression(node) || isNewExpression(node)) {
+            if (isCallExpression(node)) {
+                each(node);
+            }
+            runs(node.expression);
+            for (const argument of node.arguments ?? []) {
+                runs(argument);
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+}
+/** The entries every bundler call one build script runs names, read against `dir`. */
+function scriptEntries(file, dir, files) {
+    const module = staticModule(file);
+    const building = new Map();
+    for (const api of BUNDLERS) {
+        for (const one of module.calls(api.module)) {
+            if (api.calls.includes(one.export)) {
+                building.set(one.call, api);
+            }
+        }
+    }
+    const scriptDir = dirnamePath(file.fileName);
+    const found = [];
+    runCalls(file, (call) => {
+        const api = building.get(call);
+        if (api === undefined) {
+            return;
+        }
+        for (const options of module.argument(call)) {
+            const entries = lastMember(options, api.option);
+            const base = api.base === "" ? undefined : lastMember(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 command strings run or name, by absolute path, each below the target root. */
+function scriptModules(host, root, dir) {
+    const manifest = manifestAt(host, dir);
+    const found = new Set();
+    for (const { command } of manifest === undefined ? [] : manifestCommands(host, dir, manifest)) {
+        for (const { path } of pathsNamed(readCommands(command, dir))) {
+            if (extensionOf(path, MODULE_EXTENSIONS) !== undefined &&
+                relativePath(root, path) !== undefined &&
+                !inInstalledPackages(path) &&
+                host.kindOf(path) === "file") {
+                found.add(path);
+            }
+        }
+    }
+    return [...found].sort(bytewise);
+}
+/**
+ * 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 (const dir of ancestors(dirnamePath(file.fileName), root)) {
+            if (dirs.has(dir)) {
+                break;
+            }
+            dirs.add(dir);
+        }
+    }
+    const found = [];
+    for (const dir of [...dirs].sort(bytewise)) {
+        if (!holdsManifest(host, dir)) {
+            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/{configuration-files.js → entries/configuration-files.js}

@@ -6,29 +6,32 @@
  * every string either holds as it likes, so each one that spells a declared dependency
  * uses it and each relative one that names a source file of the program roots the file.
  */
-import { isCallExpression, isExportDeclaration, isIdentifier, isImportDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
-const MANIFEST = "package.json";
+import { isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/ast";
+import { relativeSpecifiers } from "./static-module.js";
+import { ancestors, dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath, startsRelativePath, } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { isRecord } from "../json-document.js";
+import { filesIn } from "../fs/tree.js";
+import { DEPENDENCY_SECTIONS, holdsManifest, inInstalledPackages, manifestAt, readJSON, } from "../fs/manifest.js";
+import { readCommands } from "../commands/read.js";
+import { manifestCommands } from "../roots/manifest.js";
+import { APPENDED_EXTENSIONS, extensionOf, MODULE_EXTENSIONS } from "../extensions.js";
+/** The extensions of a configuration module, as an expression's alternatives. */
+const MODULE_NAME = MODULE_EXTENSIONS.map((one) => one.slice(1)).join("|");
 /** A configuration module's name, each form with the spelling a root reports it by. */
 const MODULE_FORMS = [
-    { name: /^[\w-]+\.config\.(?:js|mjs|cjs|ts|mts|cts)$/u, form: "<stem>.config.<ext>" },
     {
-        name: /^[\w-]+\.[\w-]+\.config\.(?:js|mjs|cjs|ts|mts|cts)$/u,
+        name: new RegExp(String.raw `^[\w-]+\.config\.(?:${MODULE_NAME})$`, "u"),
+        form: "<stem>.config.<ext>",
+    },
+    {
+        name: new RegExp(String.raw `^[\w-]+\.[\w-]+\.config\.(?:${MODULE_NAME})$`, "u"),
         form: "<stem>.<qualifier>.config.<ext>",
     },
     { name: /^\.[\w-]+rc\.(?:js|mjs|cjs)$/u, form: ".<stem>rc.<ext>" },
 ];
 /** A JSON configuration file's name. */
 const DOCUMENT_NAME = /^(?:[\w-]+(?:\.[\w-]+)?\.config\.json|\.[\w-]+rc(?:\.json)?)$/u;
-/** The manifest members a dependency is declared in. */
-const DEPENDENCY_MEMBERS = [
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "optionalDependencies",
-];
-/** The prefixes a string names a file with, relative to the file that writes it. */
-const RELATIVE_PREFIXES = ["./", "../"];
 /** The JavaScript extensions a relative specifier from a configuration file stands for TypeScript under. */
 const COUNTERPARTS = [
     [".js", [".ts", ".tsx"]],
@@ -36,8 +39,6 @@ const COUNTERPARTS = [
     [".mjs", [".mts"]],
     [".cjs", [".cts"]],
 ];
-/** The extensions appended to a relative specifier from a configuration file, in order. */
-const APPENDED = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 /** The extensions the program's module resolution appends to a specifier written without one. */
 export const RESOLVED_EXTENSIONS = [
     ".ts",
@@ -50,18 +51,14 @@ export const RESOLVED_EXTENSIONS = [
     ".mjs",
     ".cjs",
 ];
-/** The directory a package manager installs packages into, whose files are no project's own. */
-const MODULES_DIR = "node_modules";
 /** The file's name, the last segment of its path. */
 function basename(path) {
     return path.slice(path.lastIndexOf("/") + 1);
 }
 /** Whether one path is the project's own: below the target root and in no `node_modules`. */
 function isProjectPath(root, path) {
-    return relativePath(root, path)?.split("/").includes(MODULES_DIR) === false;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+    const below = relativePath(root, path);
+    return below !== undefined && !inInstalledPackages(below);
 }
 /** The form one file name is as a configuration module, or undefined where it is none. */
 export function configurationModuleForm(name) {
@@ -71,161 +68,26 @@ export function configurationModuleForm(name) {
 export function isConfigurationDocumentName(name) {
     return DOCUMENT_NAME.test(name);
 }
-/** The flags a tool's command line names its configuration file with. */
-const CONFIG_FLAGS = new Set(["--config", "-c"]);
-/** The extensions of a module a configuration flag may name. */
-const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
-/** The characters that end a word outside quotes and separate nothing: blanks. */
-// Stryker disable next-line Regex: its \v to \V mutant is no valid escape under the u flag, so the whole module fails to parse
-const BLANK = /[ \t\r\f\v]/u;
-/** The characters that end a word outside quotes and begin an operator: newline included. */
-const OPERATOR = /[\n;&|()<>]/u;
-/** The characters a backslash escapes inside double quotes; before any other it stands for itself. */
-const DOUBLE_QUOTE_ESCAPES = new Set(["$", "`", '"', "\\"]);
-/**
- * The words of one command line, as POSIX token recognition reads quotes, backslashes,
- * line continuations, comments and operators. A word an expansion may change (an unquoted
- * `$`, backquote, glob character or leading `~`, or a `$` or backquote in double quotes)
- * is computed, and so is the rest of a line whose quote is never closed. A computed word
- * and each operator are undefined, so a flag's file is never read across them.
- */
-function shellWords(command) {
-    const words = [];
-    let word;
-    let computed = false;
-    const end = () => {
-        if (word !== undefined) {
-            words.push(computed ? undefined : word);
-        }
-        word = undefined;
-        computed = false;
-    };
-    for (let at = 0; at < command.length; at += 1) {
-        const char = command.charAt(at);
-        if (char === "\\" && command.charAt(at + 1) === "\n") {
-            at += 1;
-        }
-        else if (BLANK.test(char)) {
-            end();
-        }
-        else if (OPERATOR.test(char)) {
-            end();
-            words.push(undefined);
-        }
-        else if (char === "#" && word === undefined) {
-            const newline = command.indexOf("\n", at);
-            at = newline < 0 ? command.length : newline - 1;
-        }
-        else if (char === "\\") {
-            at += 1;
-            word = (word ?? "") + command.charAt(at);
-        }
-        else if (char === "'" || char === '"') {
-            const close = closingQuote(command, at);
-            if (close < 0) {
-                word ??= "";
-                computed = true;
-                break;
-            }
-            const quoted = char === "'"
-                ? { text: command.slice(at + 1, close), computed: false }
-                : doubleQuoted(command.slice(at + 1, close));
-            word = (word ?? "") + quoted.text;
-            computed ||= quoted.computed;
-            at = close;
-        }
-        else {
-            computed ||= /[$`*?[]/u.test(char) || (char === "~" && word === undefined);
-            word = (word ?? "") + char;
-        }
-    }
-    end();
-    return words;
-}
-/** The text between one pair of double quotes, unescaped, and whether an expansion may change it. */
-function doubleQuoted(inner) {
-    let text = "";
-    let computed = false;
-    for (let at = 0; at < inner.length; at += 1) {
-        const char = inner.charAt(at);
-        const next = inner.charAt(at + 1);
-        if (char === "\\" && next === "\n") {
-            at += 1;
-        }
-        else if (char === "\\" && DOUBLE_QUOTE_ESCAPES.has(next)) {
-            text += next;
-            at += 1;
-        }
-        else {
-            computed ||= char === "$" || char === "`";
-            text += char;
-        }
-    }
-    return { text, computed };
-}
-/** The index of the quote that closes the one at `open`, or -1 where none does. */
-function closingQuote(command, open) {
-    const quote = command.charAt(open);
-    for (let at = open + 1; at < command.length; at += 1) {
-        const char = command.charAt(at);
-        if (char === quote) {
-            return at;
-        }
-        if (quote === '"' && char === "\\") {
-            at += 1;
-        }
-    }
-    return -1;
-}
 /**
- * The files the scripts of the manifest in one directory name after a configuration flag,
- * `--config <file>`, `-c <file>` or `--config=<file>`, each a JSON file or a module below
- * the target root and in no `node_modules`.
+ * The files the command strings of the manifest in one directory name after a configuration
+ * flag, as `commands/read.ts` reads them against the directory each command runs in, each a
+ * JSON file or a module below the target root and in no `node_modules`.
  */
 function scriptConfigurations(host, root, dir) {
-    let scripts;
-    try {
-        const manifest = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
-        scripts = isRecord(manifest) ? manifest["scripts"] : undefined;
-    }
-    catch {
-        return [];
-    }
-    if (!isRecord(scripts)) {
-        return [];
-    }
+    const manifest = manifestAt(host, dir);
     const found = [];
-    for (const command of Object.values(scripts)) {
-        if (typeof command !== "string") {
-            continue;
-        }
-        const words = shellWords(command);
-        words.forEach((word, at) => {
-            const named = word !== undefined && CONFIG_FLAGS.has(word)
-                ? words[at + 1]
-                : word === undefined
-                    ? undefined
-                    : /^--config=(.+)$/su.exec(word)?.[1];
-            const path = named === undefined ? undefined : resolvePath(dir, named);
-            if (path !== undefined &&
-                [".json", ...MODULE_EXTENSIONS].some((extension) => path.endsWith(extension)) &&
+    for (const { command } of manifest === undefined ? [] : manifestCommands(host, dir, manifest)) {
+        for (const { dir: runs, written } of readCommands(command, dir).configurations) {
+            const path = resolvePath(runs, written);
+            if ([".json", ...MODULE_EXTENSIONS].some((extension) => path.endsWith(extension)) &&
                 isProjectPath(root, path) &&
                 host.kindOf(path) === "file") {
                 found.push(path);
             }
-        });
+        }
     }
     return found;
 }
-/** The decoded value of one JSON file, or undefined where it cannot be read or parsed. */
-function readDocument(host, path) {
-    try {
-        return JSON.parse(host.readFile(path));
-    }
-    catch {
-        return undefined;
-    }
-}
 /** Every string value one decoded JSON value holds at any depth. */
 export function documentStrings(value) {
     if (typeof value === "string") {
@@ -258,10 +120,10 @@ export function moduleStrings(file) {
 export function configurationFiles(host, targetRoot, files, parse) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const manifests = new Map();
-    const holdsManifest = (dir) => {
+    const manifestHeld = (dir) => {
         let held = manifests.get(dir);
         if (held === undefined) {
-            held = host.kindOf(joinPath(dir, MANIFEST)) === "file";
+            held = holdsManifest(host, dir);
             manifests.set(dir, held);
         }
         return held;
@@ -271,30 +133,23 @@ export function configurationFiles(host, targetRoot, files, parse) {
     for (const file of files.byPath.values()) {
         const form = configurationModuleForm(basename(file.fileName));
         const fileDir = dirnamePath(file.fileName);
-        if (form !== undefined && holdsManifest(fileDir)) {
+        if (form !== undefined && manifestHeld(fileDir)) {
             modules.push({ file, form, manifestDir: fileDir });
         }
-        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 pending = [];
     const named = [];
-    for (const dir of [...dirs].sort()) {
-        if (!holdsManifest(dir)) {
+    for (const dir of [...dirs].sort(bytewise)) {
+        if (!manifestHeld(dir)) {
             continue;
         }
-        let names;
-        try {
-            names = host
-                .readDirectory(dir)
-                .filter((entry) => !entry.directory && isConfigurationDocumentName(entry.name))
-                .map((entry) => entry.name)
-                .sort();
-        }
-        catch {
-            names = [];
-        }
+        const names = filesIn(host, dir, isConfigurationDocumentName);
         pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
         for (const path of scriptConfigurations(host, root, dir)) {
             const held = files.byName.get(path);
@@ -318,7 +173,7 @@ export function configurationFiles(host, targetRoot, files, parse) {
             continue;
         }
         if (document === undefined) {
-            const value = readDocument(host, next.path);
+            const value = readJSON(host, next.path);
             if (value === undefined) {
                 unreadable.add(next.path);
                 continue;
@@ -328,9 +183,7 @@ export function configurationFiles(host, targetRoot, files, parse) {
         }
         document.manifestDirs.push(next.manifestDir);
         for (const text of document.strings) {
-            const path = RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix))
-                ? resolvePath(dirnamePath(next.path), text)
-                : undefined;
+            const path = startsRelativePath(text) ? resolvePath(dirnamePath(next.path), text) : undefined;
             if (path?.endsWith(".json") === true &&
                 isProjectPath(root, path) &&
                 host.kindOf(path) === "file") {
@@ -343,50 +196,9 @@ export function configurationFiles(host, targetRoot, files, parse) {
         documents: [...documents.values()],
         outside: parse === undefined
             ? []
-            : outsideModules(host, root, [...dirs], files, holdsManifest, parse, named),
+            : outsideModules(host, root, [...dirs], files, manifestHeld, parse, named),
     };
 }
-/** The literal module specifier one `require(...)` or `import(...)` call names, if any. */
-function calledSpecifier(node) {
-    if (!isCallExpression(node) || node.arguments.length !== 1) {
-        return undefined;
-    }
-    const callee = node.expression;
-    const loads = callee.kind === SyntaxKind.ImportKeyword || (isIdentifier(callee) && callee.text === "require");
-    return loads ? node.arguments[0] : undefined;
-}
-/**
- * The relative specifiers one file's imports and re-exports name, and those its
- * `require(...)` and `import(...)` calls name by a literal.
- */
-export function relativeSpecifiers(file) {
-    const known = specifiersOf.get(file);
-    if (known !== undefined) {
-        return known;
-    }
-    const found = [];
-    const named = (specifier) => {
-        if (specifier !== undefined &&
-            (isStringLiteral(specifier) || isNoSubstitutionTemplateLiteral(specifier)) &&
-            RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))) {
-            found.push(specifier.text);
-        }
-    };
-    const visit = (node) => {
-        named(calledSpecifier(node));
-        node.forEachChild(visit);
-    };
-    for (const statement of file.statements) {
-        named(isImportDeclaration(statement) || isExportDeclaration(statement)
-            ? statement.moduleSpecifier
-            : undefined);
-        visit(statement);
-    }
-    specifiersOf.set(file, found);
-    return found;
-}
-/** What {@link relativeSpecifiers} found in each file, which every project of a run reads alike. */
-const specifiersOf = new WeakMap();
 /**
  * The files no program holds that a chain from `seeds` reads: each seed, and each file
  * below the target root one imports, re-exports or loads by a relative specifier that no
@@ -407,7 +219,7 @@ export function outsideChain(host, targetRoot, files, parse, seeds) {
 export function specifierCandidates(dir, specifier) {
     const path = resolvePath(dir, specifier);
     const candidates = [];
-    if (APPENDED.some((extension) => path.endsWith(extension))) {
+    if (extensionOf(path, APPENDED_EXTENSIONS) !== undefined) {
         candidates.push(path);
     }
     for (const [extension, counterparts] of COUNTERPARTS) {
@@ -416,8 +228,8 @@ export function specifierCandidates(dir, specifier) {
             candidates.push(...counterparts.map((one) => stem + one));
         }
     }
-    candidates.push(...APPENDED.map((extension) => path + extension));
-    candidates.push(...APPENDED.map((extension) => joinPath(path, `index${extension}`)));
+    candidates.push(...APPENDED_EXTENSIONS.map((extension) => path + extension));
+    candidates.push(...APPENDED_EXTENSIONS.map((extension) => joinPath(path, `index${extension}`)));
     return candidates;
 }
 /** The file on disk one relative specifier from a configuration file reaches, or undefined. */
@@ -429,23 +241,13 @@ export function resolveRelativeSpecifier(host, dir, specifier) {
  * does not hold, and the project files below `root` they import by a relative specifier,
  * until no further file joins. A file that cannot be read is skipped.
  */
-function outsideModules(host, root, dirs, files, holdsManifest, parse, named) {
+function outsideModules(host, root, dirs, files, manifestHeld, parse, named) {
     const pending = [...named];
-    for (const dir of [...dirs].sort()) {
-        if (!holdsManifest(dir)) {
-            continue;
-        }
-        let names;
-        try {
-            names = host
-                .readDirectory(dir)
-                .filter((entry) => !entry.directory && configurationModuleForm(entry.name) !== undefined)
-                .map((entry) => entry.name)
-                .sort();
-        }
-        catch {
+    for (const dir of [...dirs].sort(bytewise)) {
+        if (!manifestHeld(dir)) {
             continue;
         }
+        const names = filesIn(host, dir, (name) => configurationModuleForm(name) !== undefined);
         pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
     }
     const found = new Map();
@@ -481,18 +283,12 @@ function outsideModules(host, root, dirs, files, holdsManifest, parse, named) {
 }
 /** Every dependency the manifest in one directory declares, or none where it holds none to read. */
 export function declaredIn(host, dir) {
-    let value;
-    try {
-        value = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
-    }
-    catch {
-        return [];
-    }
-    if (!isRecord(value)) {
+    const value = manifestAt(host, dir);
+    if (value === undefined) {
         return [];
     }
     const names = new Set();
-    for (const member of DEPENDENCY_MEMBERS) {
+    for (const member of DEPENDENCY_SECTIONS) {
         const section = value[member];
         if (isRecord(section)) {
             Object.keys(section).forEach((name) => names.add(name));
@@ -511,7 +307,7 @@ export function dependenciesNamed(text, declared) {
  * none.
  */
 export function filesNamedBy(files, dir, text) {
-    if (text === "" || text.startsWith("/") || /[*?[{]/u.test(text)) {
+    if (text === "" || isAbsolutePath(text) || /[*?[{]/u.test(text)) {
         return [];
     }
     const path = resolvePath(dir, text);