@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

package/dist/src/destructuring.js

@@ -156,8 +156,6 @@ function sourceOf(target) {
 export function destructuring(project, cap, properties = propertyTables(project.queries)) {
     const queries = project.queries;
     const tables = new Map();
-    let patternBatches = 0;
-    let patternLookups = 0;
     const tableOf = (type) => {
         const known = tables.get(type.id);
         if (known !== undefined) {
@@ -166,7 +164,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
         let table = new Map();
         if ((type.flags & TypeFlags.AnyOrUnknown) === 0) {
             const read = properties.of(type);
-            patternLookups += read.asked ? 1 : 0;
             table = isAnswered(read.properties)
                 ? new Map(read.properties.map((property) => [property.name, property]))
                 : UNANSWERED;
@@ -178,7 +175,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
         if ((type.flags & TypeFlags.Union) === 0) {
             return type;
         }
-        patternLookups += 1;
         return queries.nonNullable(type);
     };
     /**
@@ -193,11 +189,9 @@ export function destructuring(project, cap, properties = propertyTables(project.
             if (index === undefined) {
                 return undefined;
             }
-            patternLookups += 1;
             const elements = queries.typeArguments(type);
             return isAnswered(elements) ? elements[index] : UNANSWERED;
         }
-        patternLookups += 1;
         const array = queries.isArray(type);
         if (!isAnswered(array)) {
             return UNANSWERED;
@@ -205,7 +199,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
         if (!array) {
             return undefined;
         }
-        patternLookups += 1;
         const elements = queries.typeArguments(type);
         return isAnswered(elements) ? elements[0] : UNANSWERED;
     };
@@ -222,14 +215,12 @@ export function destructuring(project, cap, properties = propertyTables(project.
         if (more.length > 0) {
             return UNANSWERED;
         }
-        patternLookups += 1;
         return queries.typeOfSymbol(property);
     };
     const resultOf = (callee) => {
         if (callee === undefined || callee === UNANSWERED) {
             return callee;
         }
-        patternLookups += 1;
         const signatures = queries.signaturesOf(callee, SignatureKind.Call);
         if (!isAnswered(signatures)) {
             return UNANSWERED;
@@ -238,7 +229,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
         if (signature === undefined) {
             return undefined;
         }
-        patternLookups += 1;
         return queries.returnTypeOf(signature);
     };
     const iterations = new Map();
@@ -266,7 +256,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
         if (result !== undefined && result !== UNANSWERED) {
             let parts = [result];
             if (result.isUnionType()) {
-                patternLookups += 1;
                 parts = queries.constituents(result);
             }
             const values = isAnswered(parts)
@@ -296,7 +285,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
             if (property === undefined) {
                 return undefined;
             }
-            patternLookups += 1;
             return queries.typeOfSymbol(property);
         }
         return elementOf(defined, next.index);
@@ -317,7 +305,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
             }
         }
         const asked = [...asking];
-        patternBatches += Math.ceil(asked.length / cap);
         const answered = new Map();
         queries.typesAt(asked, cap).forEach((type, index) => {
             const node = asked[index];
@@ -347,10 +334,5 @@ export function destructuring(project, cap, properties = propertyTables(project.
             return isAnswered(table) ? table.get(read.name) : UNANSWERED;
         });
     };
-    return {
-        resolve,
-        get cost() {
-            return { patternBatches, patternLookups };
-        },
-    };
+    return { resolve };
 }

package/dist/src/element-access.js

@@ -5,8 +5,6 @@
  * target holds, the members are read at each call, by the type of the argument it passes.
  */
 import { isArrayLiteralExpression, isArrowFunction, isBinaryExpression, isCallExpression, isElementAccessExpression, isForInStatement, isForOfStatement, isFunctionDeclaration, isFunctionExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVariableDeclaration, isVariableDeclarationList, isVariableStatement, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
-import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { parenthesesRemoved } from "./unwrap.js";
 /** The assignment operators that read their target before they write it. */
@@ -153,174 +151,191 @@ function assigns(body, name) {
     return found;
 }
 /**
- * The references the element accesses of one project's own files make to the members their
- * index's literal type names, each made by the declaration holding the access or the call.
+ * The reads the element accesses of a side's files make of the members their index's literal
+ * type names, each made by the declaration holding the access or the call. A type the checker
+ * leaves unanswered holds what its answer could have read.
  */
-export function elementAccessReferences(project, held, chains, root, testFiles) {
-    const queries = project.queries;
-    const candidates = [];
-    const calls = new Map();
-    const names = [];
-    for (const file of project.ownSourceFiles()) {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        if (fileId === undefined) {
-            continue;
-        }
-        const visit = (node, from) => {
-            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
-            if (isElementAccessExpression(node) && !isLiteralIndex(node.argumentExpression)) {
-                candidates.push({ file, from: holder, access: node, use: useOf(node) });
-            }
-            if (isCallExpression(node)) {
-                calls.set(node, { file, from: holder });
-            }
-            if (isIdentifier(node)) {
-                names.push(node);
-            }
-            node.forEachChild((child) => {
-                visit(child, holder);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId);
-        });
-    }
-    if (candidates.length === 0) {
-        return [];
-    }
-    // A parameter index is decided at the calls only where the function is a callable every
-    // use of which is a call, so the symbols of the parameters and of every name are read.
-    const parameterOf = new Map();
-    const byCallable = new Map();
-    for (const candidate of candidates) {
-        const index = parenthesesRemoved(candidate.access.argumentExpression);
-        const fn = isIdentifier(index) ? enclosingFunction(candidate.access) : undefined;
-        const callable = fn === undefined ? undefined : callableOf(fn);
-        if (callable === undefined || !isIdentifier(index)) {
-            continue;
-        }
-        const at = callable.parameters.findIndex((parameter) => isIdentifier(parameter.name) && parameter.name.text === index.text);
-        if (at < 0 || assigns(callable.body, index.text)) {
-            continue;
-        }
-        parameterOf.set(candidate, { callable, at });
-        byCallable.set(callable.name, [...(byCallable.get(callable.name) ?? []), candidate]);
-    }
-    const callableNames = [...byCallable.keys()];
-    const spelled = new Set(callableNames.map((name) => name.text));
-    const sameName = names.filter((name) => spelled.has(name.text));
-    const symbols = queries.symbolsAt([...callableNames, ...sameName]);
-    const symbolOf = new Map();
-    [...callableNames, ...sameName].forEach((node, at) => {
-        const symbol = symbols[at];
-        if (symbol !== UNANSWERED && symbol !== undefined) {
-            symbolOf.set(node, symbol);
-        }
-    });
-    const callsOf = new Map();
-    for (const name of callableNames) {
-        const symbol = symbolOf.get(name);
-        let found = symbol === undefined ? undefined : [];
-        for (const use of sameName) {
-            if (found === undefined) {
-                break;
-            }
-            if (use === name || symbolOf.get(use) !== symbol) {
-                continue;
-            }
-            const parent = use.parent;
-            found =
-                isCallExpression(parent) && parent.expression === use ? [...found, parent] : undefined;
-        }
-        callsOf.set(name, found);
-    }
-    const lookups = [];
-    for (const candidate of candidates) {
-        const deferred = parameterOf.get(candidate);
-        const sites = deferred === undefined ? undefined : callsOf.get(deferred.callable.name);
-        if (deferred === undefined || sites === undefined) {
-            lookups.push({
-                file: candidate.file,
-                from: candidate.from,
-                at: candidate.access.argumentExpression,
-                object: candidate.access.expression,
-                index: candidate.access.argumentExpression,
-                use: candidate.use,
-            });
-            continue;
-        }
-        // An object that is a parameter too is read as the argument each call passes there.
-        const object = parenthesesRemoved(candidate.access.expression);
-        const objectAt = isIdentifier(object)
-            ? deferred.callable.parameters.findIndex((parameter) => isIdentifier(parameter.name) && parameter.name.text === object.text)
-            : -1;
-        for (const call of sites) {
-            const parameter = deferred.callable.parameters[deferred.at];
-            const index = call.arguments[deferred.at] ?? parameter?.initializer;
-            const site = calls.get(call);
-            if (index === undefined || site === undefined) {
-                continue;
-            }
-            lookups.push({
-                file: site.file,
-                from: site.from,
-                at: call,
-                object: (objectAt < 0 ? undefined : call.arguments[objectAt]) ?? candidate.access.expression,
-                index,
-                use: candidate.use,
-            });
-        }
-    }
-    const nodes = lookups.flatMap((one) => [one.index, one.object]);
-    const types = queries.typesAt(nodes);
-    const typeOf = (node, at) => {
-        const type = types[at];
-        return nodes[at] === node && type !== UNANSWERED ? type : undefined;
-    };
-    // A type parameter's body serves every instantiation, so it reads what its constraint admits.
-    const keysOf = (type) => {
-        if (!type.isTypeParameter()) {
-            return type;
-        }
-        const constraint = queries.constraintOf(type);
-        return constraint === UNANSWERED || constraint === undefined ? type : constraint;
-    };
-    const partsOf = (type) => {
-        const parts = queries.constituents(type);
-        return parts === UNANSWERED ? [type] : parts;
-    };
-    const found = [];
-    lookups.forEach((lookup, at) => {
-        const indexType = typeOf(lookup.index, 2 * at);
-        const objectType = typeOf(lookup.object, 2 * at + 1);
-        const literals = indexType === undefined ? undefined : literalNames(partsOf(keysOf(indexType)));
-        if (objectType === undefined || literals === undefined) {
-            return;
-        }
-        const position = renderPosition(lookup.file, root, lookup.at.getStart());
-        for (const part of partsOf(objectType)) {
-            const properties = queries.propertiesOf(part);
-            for (const property of properties === UNANSWERED ? [] : properties) {
-                if (!literals.has(property.escapedName)) {
-                    continue;
+export const elementAccess = {
+    start() {
+        const candidates = [];
+        const calls = new Map();
+        const names = [];
+        return {
+            visit(node, { file, from }) {
+                if (isElementAccessExpression(node) && !isLiteralIndex(node.argumentExpression)) {
+                    candidates.push({ file, from, access: node, use: useOf(node) });
+                }
+                if (isCallExpression(node)) {
+                    calls.set(node, { file, from });
+                }
+                if (isIdentifier(node)) {
+                    names.push(node);
                 }
-                for (const to of chains.declarationsOf(property)) {
-                    for (const use of lookup.use === "both" ? ["read", "write"] : [lookup.use]) {
+            },
+            reads({ project, chains }) {
+                const found = [];
+                if (candidates.length === 0) {
+                    return found;
+                }
+                const queries = project.queries;
+                // A parameter index is decided at the calls only where the function is a callable every
+                // use of which is a call, so the symbols of the parameters and of every name are read.
+                const parameterOf = new Map();
+                const byCallable = new Map();
+                for (const candidate of candidates) {
+                    const index = parenthesesRemoved(candidate.access.argumentExpression);
+                    const fn = isIdentifier(index) ? enclosingFunction(candidate.access) : undefined;
+                    const callable = fn === undefined ? undefined : callableOf(fn);
+                    if (callable === undefined || !isIdentifier(index)) {
+                        continue;
+                    }
+                    const at = callable.parameters.findIndex((parameter) => isIdentifier(parameter.name) && parameter.name.text === index.text);
+                    if (at < 0 || assigns(callable.body, index.text)) {
+                        continue;
+                    }
+                    parameterOf.set(candidate, { callable, at });
+                    byCallable.set(callable.name, [...(byCallable.get(callable.name) ?? []), candidate]);
+                }
+                const callableNames = [...byCallable.keys()];
+                const spelled = new Set(callableNames.map((name) => name.text));
+                const sameName = names.filter((name) => spelled.has(name.text));
+                const asked = [...callableNames, ...sameName];
+                const symbols = queries.symbolsAt(asked);
+                const symbolOf = new Map();
+                asked.forEach((node, at) => {
+                    const symbol = symbols[at];
+                    if (symbol !== undefined) {
+                        symbolOf.set(node, symbol);
+                    }
+                });
+                const callsOf = new Map();
+                for (const name of callableNames) {
+                    const symbol = symbolOf.get(name);
+                    let sites = symbol === undefined || symbol === UNANSWERED ? undefined : [];
+                    for (const use of sameName) {
+                        if (sites === undefined) {
+                            break;
+                        }
+                        const other = symbolOf.get(use);
+                        if (use === name || (other !== symbol && other !== UNANSWERED)) {
+                            continue;
+                        }
+                        // A use the checker could not resolve may be the function's, read where it is not called.
+                        const parent = use.parent;
+                        sites =
+                            other !== UNANSWERED && isCallExpression(parent) && parent.expression === use
+                                ? [...sites, parent]
+                                : undefined;
+                    }
+                    callsOf.set(name, sites);
+                }
+                const lookups = [];
+                for (const candidate of candidates) {
+                    const deferred = parameterOf.get(candidate);
+                    const sites = deferred === undefined ? undefined : callsOf.get(deferred.callable.name);
+                    if (deferred === undefined || sites === undefined) {
+                        lookups.push({
+                            file: candidate.file,
+                            from: candidate.from,
+                            at: candidate.access.argumentExpression,
+                            object: candidate.access.expression,
+                            index: candidate.access.argumentExpression,
+                            use: candidate.use,
+                        });
+                        continue;
+                    }
+                    // An object that is a parameter too is read as the argument each call passes there.
+                    const object = parenthesesRemoved(candidate.access.expression);
+                    const objectAt = isIdentifier(object)
+                        ? deferred.callable.parameters.findIndex((parameter) => isIdentifier(parameter.name) && parameter.name.text === object.text)
+                        : -1;
+                    for (const call of sites) {
+                        const parameter = deferred.callable.parameters[deferred.at];
+                        const index = call.arguments[deferred.at] ?? parameter?.initializer;
+                        const site = calls.get(call);
+                        if (index === undefined || site === undefined) {
+                            continue;
+                        }
+                        lookups.push({
+                            file: site.file,
+                            from: site.from,
+                            at: call,
+                            object: (objectAt < 0 ? undefined : call.arguments[objectAt]) ??
+                                candidate.access.expression,
+                            index,
+                            use: candidate.use,
+                        });
+                    }
+                }
+                const nodes = lookups.flatMap((one) => [one.index, one.object]);
+                const types = queries.typesAt(nodes);
+                // A type parameter's body serves every instantiation, so it reads what its constraint admits.
+                const keysOf = (type) => {
+                    if (!type.isTypeParameter()) {
+                        return type;
+                    }
+                    const constraint = queries.constraintOf(type);
+                    return constraint === UNANSWERED || constraint === undefined ? type : constraint;
+                };
+                const partsOf = (type) => {
+                    const parts = queries.constituents(type);
+                    return parts === UNANSWERED ? [type] : parts;
+                };
+                lookups.forEach((lookup, at) => {
+                    const indexType = types[2 * at];
+                    const objectType = types[2 * at + 1];
+                    const literals = indexType === undefined || indexType === UNANSWERED
+                        ? undefined
+                        : literalNames(partsOf(keysOf(indexType)));
+                    if (indexType === UNANSWERED || objectType === UNANSWERED) {
                         found.push({
+                            kind: "held",
                             from: lookup.from,
-                            to,
-                            position,
-                            use,
-                            resolution: "keyed",
-                            test: testFiles.has(position.path),
+                            ...(literals === undefined ? {} : { names: [...literals] }),
+                            ...(objectType === UNANSWERED || objectType === undefined
+                                ? literals === undefined
+                                    ? { members: true }
+                                    : {}
+                                : { types: partsOf(objectType) }),
                         });
+                        return;
                     }
-                }
-            }
-        }
-    });
-    return found;
-}
+                    if (objectType === undefined || literals === undefined) {
+                        return;
+                    }
+                    for (const part of partsOf(objectType)) {
+                        const properties = queries.propertiesOf(part);
+                        if (properties === UNANSWERED) {
+                            found.push({ kind: "held", from: lookup.from, names: [...literals] });
+                            continue;
+                        }
+                        for (const property of properties) {
+                            if (!literals.has(property.escapedName)) {
+                                continue;
+                            }
+                            for (const to of chains.declarationsOf(property)) {
+                                for (const use of lookup.use === "both"
+                                    ? ["read", "write"]
+                                    : [lookup.use]) {
+                                    found.push({
+                                        kind: "named",
+                                        from: lookup.from,
+                                        to,
+                                        file: lookup.file,
+                                        at: lookup.at,
+                                        use,
+                                        via: "keyed",
+                                    });
+                                }
+                            }
+                        }
+                    }
+                });
+                return found;
+            },
+        };
+    },
+};
 /** The names a union of literal types spells, or none where a constituent is no string or number literal. */
 function literalNames(parts) {
     const names = new Set();

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;
+}