@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.11

package/dist/src/augmentations.js

@@ -6,54 +6,147 @@
  * 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) {
+export function isGlobalBlock(symbol, held, files) {
     return (symbol.kind === "namespace" &&
         files.has(symbol.parent) &&
         symbol.ref.endsWith("#global") &&
         !held.modules.has(symbol.id));
 }
 /**
- * For each reference to a declaration an augmentation block, or the global scope of a
- * file in `scripts`, holds, a read at the same place of every interface and namespace
- * between it and the block or the file, and of the block itself. `scripts` holds the
- * files that are no module, by identifier.
+ * Per declaration, the interfaces and namespaces between it and the augmentation block or
+ * the file in `scripts` that holds it, with the block itself, or none where no such block
+ * or file holds it; and whether that holder is the global scope rather than a module
+ * declaration. `scripts` holds the files that are no module, by identifier.
  */
-export function augmentationReferences(held, found, scripts = new Set()) {
+function holdersOf(held, scripts) {
     const files = new Set(held.symbols.filter((one) => one.kind === "file").map((one) => one.id));
     const globals = new Set(held.symbols.filter((one) => isGlobalBlock(one, held, files)).map((one) => one.id));
     if (globals.size === 0 && held.modules.size === 0 && scripts.size === 0) {
-        return [];
+        return undefined;
     }
     const byId = new Map(held.symbols.map((one) => [one.id, one]));
-    const holders = (id) => {
+    return (id) => {
         const ids = [];
         for (let at = byId.get(byId.get(id)?.parent ?? ""); at !== undefined; at = byId.get(at.parent)) {
             if (globals.has(at.id) || held.modules.has(at.id)) {
-                return [...ids, at.id];
+                return { ids: [...ids, at.id], global: globals.has(at.id) };
             }
             if (scripts.has(at.id)) {
-                return ids;
+                return { ids, global: true };
             }
             if (at.kind === "interface" || at.kind === "namespace") {
                 ids.push(at.id);
             }
         }
+        return { ids: [], global: false };
+    };
+}
+/**
+ * The ambient interfaces of the global scope among `interfaces`: each one a declaration
+ * file or a `declare` holds that a `declare global` block, or the top level of a file in
+ * `scripts`, declares, directly or inside a namespace there.
+ */
+export function ambientGlobalInterfaces(held, interfaces, scripts) {
+    const holders = holdersOf(held, scripts);
+    return holders === undefined
+        ? []
+        : 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
+ * every interface and namespace between it and the block or the file, and of the block
+ * itself. A read through an interface of `merged`, an ambient global interface merging
+ * into a language or library one, is a production read whoever writes it: it types a
+ * value the runtime provides, so a test reading a member needs it as code does.
+ */
+export function augmentationReferences(held, found, scripts = new Set(), merged = new Set()) {
+    const holders = holdersOf(held, scripts);
+    if (holders === undefined) {
+        return [];
+    }
+    const fileOf = new Map(held.symbols.filter((one) => one.kind === "file").map((one) => [one.position.path, one.id]));
     // Two uses at one place of declarations one block holds read the block once there.
     const made = new Set(found.map(referenceKey));
     const reads = new Map();
     for (const reference of found) {
-        for (const to of holders(reference.to)) {
+        const { ids } = holders(reference.to);
+        // A test's read through such an interface is held by the test file, which the test
+        // runner loads whichever of its declarations runs.
+        const typed = reference.test && ids.some((id) => merged.has(id));
+        const from = typed ? (fileOf.get(reference.position.path) ?? reference.from) : reference.from;
+        for (const to of ids) {
             const read = {
-                from: reference.from,
+                from,
                 to,
                 position: reference.position,
                 use: "read",
                 resolution: reference.resolution,
-                test: reference.test,
+                test: reference.test && !typed,
             };
             const key = referenceKey(read);
             if (!made.has(key) && !reads.has(key)) {

package/dist/src/automatic-types.js

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

package/dist/src/build-scripts.js

@@ -0,0 +1,425 @@
+/**
+ * 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, isCallExpression, isConstructorDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isImportDeclaration, isMetaProperty, isMethodDeclaration, isNamedImports, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isSetAccessorDeclaration, isStringLiteral, isVariableDeclaration, isVariableStatement, NodeFlags, } from "@typescript/native/ast";
+import { filesNamedBy } from "./configuration-files.js";
+import { ancestors, dirnamePath, relativePath, resolvePath } from "./paths.js";
+import { bytewise } from "./text/compare.js";
+import { isRecord } from "./json-document.js";
+import { unwrapped } from "./unwrap.js";
+import { holdsManifest, inInstalledPackages, manifestAt } from "./fs/manifest.js";
+import { globExpression } from "./text/glob.js";
+import { scriptTokens } from "./text/shell.js";
+/**
+ * The bundlers whose build call names its entries: esbuild resolves `entryPoints` against
+ * `absWorkingDir` (https://esbuild.github.io/api/#working-directory), webpack `entry`
+ * 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;
+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) {
+    const scripts = manifestAt(host, dir)?.["scripts"];
+    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 &&
+                !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/component-layer.js

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