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

package/dist/src/references/sink.js

@@ -13,12 +13,15 @@ export class Sink {
     #testFile;
     #consumer;
     #found = [];
+    #declaredAt;
     #valued = new Map();
+    #named = new Map();
     #held = new Set();
-    constructor(root, testFile, consumer) {
+    constructor(root, testFile, consumer, declaredAt) {
         this.#root = root;
         this.#testFile = testFile;
         this.#consumer = consumer;
+        this.#declaredAt = declaredAt;
     }
     /** Whether a test file wrote one walked file's uses. */
     isTest(file) {
@@ -47,6 +50,11 @@ export class Sink {
                 test,
                 ...(target.guessed === true ? { guessed: true } : {}),
             });
+            if (this.#consumer === undefined && !("column" in at)) {
+                const named = this.#named.get(file) ?? [];
+                named.push({ index: this.#found.length - 1, at, annotated: this.#annotates(at, from) });
+                this.#named.set(file, named);
+            }
             if (use === "write" && value !== undefined) {
                 const valued = this.#valued.get(file) ?? [];
                 valued.push({ index: this.#found.length - 1, value });
@@ -54,6 +62,26 @@ export class Sink {
             }
         }
     }
+    /**
+     * Whether a name sits in the annotation of `from`'s own declaration. An annotation holds
+     * no block, so the walk stops at the first declaration or block above the name.
+     */
+    #annotates(name, from) {
+        if (name.kind === SyntaxKind.SourceFile) {
+            return false;
+        }
+        let child = name;
+        let parent = name.parent;
+        while (parent.kind !== SyntaxKind.Block && parent.kind !== SyntaxKind.SourceFile) {
+            const id = this.#declaredAt(parent);
+            if (id !== undefined) {
+                return id === from && parent.type === child;
+            }
+            child = parent;
+            parent = parent.parent;
+        }
+        return false;
+    }
     /** Holds declarations an unanswered question could have made live, and the one whose read asked it. */
     hold(ids) {
         for (const id of ids) {
@@ -83,6 +111,14 @@ export class Sink {
                 }
             }
         }
+        for (const [file, named] of this.#named) {
+            for (const { index, carriers } of carriersIn(named, this.#valued.get(file) ?? [], found)) {
+                const reference = found[index];
+                if (reference !== undefined) {
+                    found[index] = { ...reference, carriers };
+                }
+            }
+        }
         found.sort((a, b) => byPosition(a.position, b.position) ||
             bytewise(a.to, b.to) ||
             bytewise(a.from, b.from) ||
@@ -149,3 +185,53 @@ function aloneIn(file, uses, writes, found) {
     }
     return result;
 }
+/**
+ * The carriers of each named record of one file: `from` where its own annotation holds the
+ * name, then the target of each write whose stored value holds it and that names another
+ * declaration, the innermost value first. Values nest or are disjoint.
+ */
+function carriersIn(named, writes, found) {
+    const byStart = [...named].sort((a, b) => a.at.pos - b.at.pos);
+    const holding = new Map();
+    for (const write of writes) {
+        let low = 0;
+        let high = byStart.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if ((byStart[middle]?.at.pos ?? 0) < write.value.pos) {
+                low = middle + 1;
+            }
+            else {
+                high = middle;
+            }
+        }
+        for (let at = low; at < byStart.length; at += 1) {
+            const one = byStart[at];
+            if (one === undefined || one.at.pos >= write.value.end) {
+                break;
+            }
+            if (one.at.end <= write.value.end) {
+                holding.set(one.index, [...(holding.get(one.index) ?? []), write]);
+            }
+        }
+    }
+    const result = [];
+    for (const one of named) {
+        const reference = found[one.index];
+        if (reference === undefined) {
+            continue;
+        }
+        const carriers = one.annotated ? [reference.from] : [];
+        const values = [...(holding.get(one.index) ?? [])].sort((a, b) => a.value.end - a.value.pos - (b.value.end - b.value.pos));
+        for (const write of values) {
+            const to = found[write.index]?.to;
+            if (to !== undefined && to !== reference.to && !carriers.includes(to)) {
+                carriers.push(to);
+            }
+        }
+        if (carriers.length > 0) {
+            result.push({ index: one.index, carriers });
+        }
+    }
+    return result;
+}

package/dist/src/references.js

@@ -49,10 +49,10 @@ export function references(project, held, targetRoot, options) {
             .ownSourceFiles()
             .filter((file) => relativePath(consumer.root, file.fileName) !== undefined &&
             relativePath(targetRoot, file.fileName) === undefined);
-    const sink = new Sink(consumer?.root ?? targetRoot, options.testFile, consumer);
     const ownPaths = project.ownPaths();
     const fileIds = new Set(held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id));
     const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
+    const sink = new Sink(consumer?.root ?? targetRoot, options.testFile, consumer, declaredAt);
     let moduleBodies;
     /**
      * The declarations one module holds directly: a file's top level, or the body of a

package/dist/src/roots/manifest.js

@@ -27,8 +27,9 @@ function below(member, key) {
 }
 /**
  * The whole text of nodemon's configuration, the manifest's `nodemonConfig` member and the
- * `nodemon.json` beside it, by the member each is. Layer 3 holds it whole, because nodemon runs
- * commands from keys besides `exec`, `events` among them: https://github.com/remy/nodemon#config-files
+ * `nodemon.json` beside it, by the member each is. The dependency rule reads it whole, and
+ * layer 3 each of its values, because nodemon runs commands from keys besides `exec`, `events`
+ * among them: https://github.com/remy/nodemon#config-files
  */
 export function nodemonTexts(host, dir, manifest) {
     const member = manifest["nodemonConfig"];
@@ -44,6 +45,39 @@ export function nodemonTexts(host, dir, manifest) {
         ...(file === undefined ? [] : [{ member: "nodemon.json", text: file }]),
     ];
 }
+/**
+ * The texts layer 3 reads of one text of nodemon's configuration: each value of it but its
+ * `exec` command, which is read as a command string of its own, those under `events` read as
+ * command strings too, and the whole text where it does not parse. Its keys are never read.
+ */
+function nodemonValues(text) {
+    let config;
+    try {
+        config = JSON.parse(text);
+    }
+    catch {
+        return [{ text, shell: false }];
+    }
+    const found = [];
+    const visit = (value, shell) => {
+        if (Array.isArray(value) || isRecord(value)) {
+            for (const one of Object.values(value)) {
+                visit(one, shell);
+            }
+        }
+        else if (typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean") {
+            found.push({ text: String(value), shell });
+        }
+    };
+    for (const [key, value] of Object.entries(isRecord(config) ? config : { "": config })) {
+        if (key !== "exec" || typeof value !== "string") {
+            visit(value, key === "events");
+        }
+    }
+    return found;
+}
 /**
  * The command strings one manifest runs, each at the member it is written under: each of its
  * `scripts`, and the `exec` command of nodemon's configuration, in the manifest's `nodemonConfig`
@@ -141,10 +175,19 @@ export function readManifest(host, targetRoot) {
         for (const path of new Set(pathsNamed(readCommands(command, ".")).map((one) => one.path))) {
             found.push({ member, path, role: "script", published: false });
         }
-        found.push({ member, path: ".", role: "script", published: false, held: command });
+        found.push({
+            member,
+            path: ".",
+            role: "script",
+            published: false,
+            held: [{ text: command, shell: true, tested: member.startsWith("scripts[") }],
+        });
     }
     for (const { member, text } of nodemonTexts(host, targetRoot, manifest)) {
-        found.push({ member, path: ".", role: "script", published: false, held: text });
+        const held = nodemonValues(text);
+        if (held.length > 0) {
+            found.push({ member, path: ".", role: "script", published: false, held });
+        }
     }
     return {
         entries: found.map((entry) => ({

package/dist/src/roots/published-reach.js

@@ -182,7 +182,7 @@ function declarationNodes(held, byPath) {
     return {
         typeNamesOf: (symbol) => {
             const { byId, nodes } = nodesIn(symbol.position.path);
-            return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, nodes));
+            return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, (nested) => nodes.has(nested)));
         },
         nodesOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id) ?? [],
     };
@@ -369,12 +369,12 @@ function inferredTypeSymbols(project, declarations) {
 /**
  * The names of types one declaration's own syntax writes: in a type reference, a
  * heritage clause or a type query. A function body is not read, and neither is a
- * declaration nested in this one, which `nested` holds and which is read on its own.
+ * declaration nested in this one that `readAlone` says is read on its own.
  */
-function typeNamesOf(declaration, nested) {
+export function typeNamesOf(declaration, readAlone) {
     const found = [];
     const visit = (node) => {
-        if (node !== declaration && nested.has(node)) {
+        if (node !== declaration && readAlone(node)) {
             return;
         }
         if (isTypeReferenceNode(node)) {

package/dist/src/roots/root-set.js

@@ -16,6 +16,7 @@ import { typeQueryAliases } from "../type-query-alias.js";
 import { bytewise } from "../text/compare.js";
 import { holdsManifest } from "../fs/manifest.js";
 import { globExpression } from "../text/glob.js";
+import { heldWords } from "../commands/held.js";
 import { spelledFiles } from "../text/named-files.js";
 import { extensionOf, OUTPUT_EXTENSIONS } from "../extensions.js";
 import { publishedAPI, releaseTagged } from "./published-reach.js";
@@ -159,11 +160,12 @@ export function matchRef(pattern, ref) {
     return matchGlob(Array.from(pattern), Array.from(ref));
 }
 /**
- * Per package, the own files its held texts name, as `spelledFiles` reads them, but those a
- * root enters with all they export: a command can use no more of such a file than the root
- * keeps live. A manifest's are its entries' held texts, and the target root's package has the
- * workflow steps, git hooks and makefile recipes beside its own, with the whole text of each
- * file they are read from.
+ * Per package, the own files the words of its held texts name, as `spelledFiles` reads them,
+ * but those a root enters with all they export: a command can use no more of such a file than
+ * the root keeps live. A manifest's are its entries' held texts, and the target root's package
+ * has the workflow steps, git hooks and makefile recipes beside its own, with the values of
+ * each file they are read from. A package is listed too where a word that may write the file
+ * a command runs writes no path text.
  */
 function scriptHolds(entries, files, entered, host, targetRoot, workflows) {
     const rooted = new Set(entered.filter((one) => one.exports && one.names === undefined).map((one) => one.file.fileName));
@@ -171,24 +173,20 @@ function scriptHolds(entries, files, entered, host, targetRoot, workflows) {
         .filter((file) => !rooted.has(file.fileName))
         .map((file) => ({ file, paths: [file.fileName, ...files.writtenAs(file)] }));
     const cwd = host.workingDirectory();
-    const commands = new Map([
-        [
-            resolvePath(cwd, targetRoot),
-            [...workflows.readings.map((reading) => reading.held), ...workflows.texts],
-        ],
-    ]);
+    const root = resolvePath(cwd, targetRoot);
+    const commands = new Map([[root, [...workflows.held]]]);
     for (const entry of entries) {
         if (entry.held !== undefined) {
             const dir = resolvePath(cwd, entry.dir);
-            commands.set(dir, [...(commands.get(dir) ?? []), entry.held]);
+            commands.set(dir, [...(commands.get(dir) ?? []), ...entry.held]);
         }
     }
     const held = [];
     for (const [dir, texts] of commands) {
-        const named = spelledFiles(texts.join("\n"), dir, spelled);
-        if (named.length > 0) {
-            const paths = named.map((file) => relativePath(targetRoot, file.fileName) ?? file.fileName);
-            held.push({ dir, files: paths });
+        const named = spelledFiles(heldWords(texts), dir, root, spelled);
+        if (named.files.length > 0 || named.unwritten) {
+            const paths = named.files.map((file) => relativePath(targetRoot, file.fileName) ?? file.fileName);
+            held.push({ dir, files: paths, unwritten: named.unwritten });
         }
     }
     return held;

package/dist/src/text/named-files.js

@@ -1,59 +1,282 @@
-/**
- * Layer 3 of the command reader: the files and the package names a command's text names, read
- * as plain text. The text is searched for each name, which every spelling of what it names
- * contains, so no part of it is split, unquoted or skipped first.
- */
+/** Layer 3 of the command reader: the files its words name, and the package names a command's text names. */
+import { PART } from "../commands/shell.js";
+import { APPENDED_EXTENSIONS, extensionOf } from "../extensions.js";
 import { dirnamePath, normalizePath, relativePath } from "../paths.js";
-/** The extension a source or an emitted file carries: a JavaScript or TypeScript one, or a declaration's. */
-const SOURCE_EXTENSION = /\.(?:d\.[cm]?ts|[cm]?[jt]s|[jt]sx)$/u;
+/** The extensions a name of a file drops: a source's, an emitted file's, and a declaration's (roots.13). */
+const NAMED_EXTENSIONS = [...APPENDED_EXTENSIONS, ".d.ts", ".d.mts", ".d.cts"];
+/** A character a package's or a command's name may hold, so one beside a name makes it part of a longer one. */
+const NAME_CHARACTER = /[\w.@-]/u;
+const SEPARATOR = /[/\\]/u;
 /**
- * The names whose presence in a text holds one path below `dir`: its last name without the
- * extension, or with it where nothing else is left, and for an `index` file its directory's
- * last name, and `.` too where that is `dir`. Every spelling of the path relative to `dir`,
- * with or without `./`, `/` or `\`, its extension or its `/index` part, and every longer path
- * ending in one, holds one of them. None is empty, because an empty name is in every text.
+ * The names whose appearance as a path in a text holds one path below `dir`: its last segment
+ * without the extension, or whole where nothing else is left or it has none, and for an
+ * `index` file its directory's last segment, and `.` too where that is `dir`. Every spelling
+ * of the path that writes it as a path holds one of them (roots.13). None is empty, because
+ * an empty name is in every text.
  */
-function stemsOf(path, dir) {
+function namesOf(path, dir) {
     const last = path.slice(path.lastIndexOf("/") + 1);
-    const bare = last.replace(SOURCE_EXTENSION, "");
-    const name = bare === "" ? last : bare;
-    if (name !== "index") {
-        return [name];
+    const bare = last.slice(0, last.length - (extensionOf(last, NAMED_EXTENSIONS)?.length ?? 0));
+    const own = bare === "" || bare === last ? { text: last, kind: "segment" } : { text: bare, kind: "stem" };
+    if (own.text !== "index") {
+        return [own];
     }
     const parent = dirnamePath(path);
+    const directory = parent.slice(parent.lastIndexOf("/") + 1);
     return [
-        name,
-        parent.slice(parent.lastIndexOf("/") + 1),
-        ...(parent === normalizePath(dir) ? ["."] : []),
-    ].filter((stem) => stem !== "");
+        own,
+        ...(directory === "" ? [] : [{ text: directory, kind: "directory" }]),
+        ...(parent === normalizePath(dir) ? [{ text: ".", kind: "root" }] : []),
+    ];
+}
+/**
+ * Whether a name that ends at `end` ends there as a path: no name character follows, nor a
+ * separator, which goes on to a path below it, nor a part, whose text goes on with the name,
+ * nor a `.` that a word character or a part follows, which goes on to another extension.
+ */
+function endsAt(text, end) {
+    const next = text.charAt(end);
+    const after = text.charAt(end + 1);
+    return (!/[\w@/\\-]/u.test(next) &&
+        next !== PART &&
+        !(next === "." && (/\w/u.test(after) || after === PART)));
+}
+/** A character a word that writes a path may hold, a part only its run knows among them. */
+const PATH_CHARACTER = new RegExp(`[\\w.@+/\\\\${PART}-]`, "u");
+/** A run of {@link PATH_CHARACTER}s: a word as {@link noFileEnd} reads one. */
+const PATH_WORD = new RegExp(`${PATH_CHARACTER.source}+`, "gu");
+const SCOPED_PACKAGE = /^@[\w-][\w.-]*\/[\w-][\w.-]*(?:@[\w.-]*)?$/u;
+/**
+ * The end of what `text` writes from `start`, where `word` starts, that names an image or a
+ * package and never a file, or `start` where it names none (roots.13): a value of a `docker:`
+ * that starts no longer name, and a scoped package's name, which no part goes on with, since
+ * a part beside it may make it a path.
+ */
+function noFileEnd(text, start, word) {
+    const end = start + word.length;
+    const image = word.startsWith("//") &&
+        start >= 7 &&
+        text.startsWith("docker:", start - 7) &&
+        !NAME_CHARACTER.test(text.charAt(start - 8));
+    return image || (SCOPED_PACKAGE.test(word) && !holdsExtension(word)) ? end : start;
+}
+/** Each place of `text` that {@link noFileEnd} rules out, as a 1. */
+function placesNamingNoFile(text) {
+    const ruledOut = new Uint8Array(text.length);
+    for (const { 0: word, index: start } of text.matchAll(PATH_WORD)) {
+        ruledOut.fill(1, start, noFileEnd(text, start, word));
+    }
+    return ruledOut;
+}
+/** The place after the separators `text` holds from `at`. */
+function pastSeparators(text, at) {
+    let after = at;
+    while (SEPARATOR.test(text.charAt(after))) {
+        after += 1;
+    }
+    return after;
+}
+/** Whether `name`, found in `text` at `at`, appears there as a path (roots.13). */
+function appearsAsPath(text, at, name) {
+    const before = text.charAt(at - 1);
+    const end = at + name.text.length;
+    if (before === PART) {
+        return false;
+    }
+    if (name.kind === "root") {
+        const after = pastSeparators(text, end);
+        return ([before, text.charAt(after)].every((one) => !NAME_CHARACTER.test(one) && !SEPARATOR.test(one)) && text.charAt(after) !== PART);
+    }
+    if (NAME_CHARACTER.test(before)) {
+        return false;
+    }
+    const after = pastSeparators(text, end);
+    if (name.kind === "directory" && after > end && endsAt(text, after)) {
+        return true;
+    }
+    if ((SEPARATOR.test(before) || (name.kind === "segment" && name.text.indexOf(".", 1) > 0)) &&
+        endsAt(text, end)) {
+        return true;
+    }
+    return (name.kind === "stem" &&
+        NAMED_EXTENSIONS.some((extension) => text.startsWith(extension, end) && endsAt(text, end + extension.length)));
+}
+/** Whether some text holds one of the extensions as a whole. */
+function holdsExtension(written) {
+    return NAMED_EXTENSIONS.some((extension) => new RegExp(`${extension.replaceAll(".", "\\.")}(?!\\w)`, "u").test(written));
+}
+/** Whether a word's segment writes path text: text beside its parts other than `.` and `..`. */
+function writesPath(segment) {
+    return segment.split(PART).some((piece) => piece !== "" && piece !== "." && piece !== "..");
+}
+/**
+ * Each run of path characters of `word`, at `start`, whose last segment holds a part, read as
+ * roots.13 reads one from past its last segment before the last that writes no path: one that
+ * writes none names nothing and is `unwritten` where the word may write the file a command runs,
+ * where a bare one names a file too. The word stands `depth` segments below the target root,
+ * whose own directories no checkout names alike: a leading `..` past it writes none, and an
+ * absolute run reads from its last segment that writes a path, `unwritten` where more is left.
+ */
+function dynamicWords(word, start, ruledOut, depth) {
+    const { text, runs } = word;
+    const found = [];
+    let unwritten = false;
+    const read = (from, next) => {
+        const entry = next < 0;
+        // A `.` the word ends with ends a sentence, as endsAt reads one after a name.
+        const run = entry ? text : text.slice(from, next).replace(/\.+$/u, "");
+        const all = run.replaceAll("\\", "/").split("/");
+        const directory = all.length > 1 && all.at(-1) === "";
+        const written = all.filter((segment) => segment !== "" && segment !== ".");
+        const last = (written.at(-1) ?? "").split(PART);
+        // A runtime's entry is a path whatever it looks like, a scoped package's name among them.
+        if (!entry && (last.length < 2 || ruledOut[start + from] === 1)) {
+            return;
+        }
+        const climbs = written.findIndex((segment) => segment !== "..");
+        const above = Math.max(0, (climbs < 0 ? written.length : climbs) - depth);
+        const segments = written.filter((_, at) => at < climbs || at >= climbs + above);
+        if (!segments.some(writesPath)) {
+            unwritten ||= runs && (!entry || above > 0);
+        }
+        else if (all.length > 1 || holdsExtension(last.join("")) || runs) {
+            const kept = directory ? segments.length : segments.length - 1;
+            const anyDirectory = segments.slice(0, kept).findLastIndex((one) => !writesPath(one));
+            const absolute = all[0] === "" && all.length > 1 && anyDirectory < 0;
+            const from = absolute ? segments.findLastIndex(writesPath) : anyDirectory + 1;
+            unwritten ||= runs && absolute && from < segments.length - 1;
+            const glob = segments.slice(from).join("/");
+            found.push({ glob: glob === "" ? ["", ""] : glob.split(PART), directory });
+        }
+    };
+    if (runs && !text.includes(PART)) {
+        read(0, -1);
+    }
+    let at = text.indexOf(PART);
+    while (at >= 0) {
+        let from = at;
+        while (from > 0 && PATH_CHARACTER.test(text.charAt(from - 1))) {
+            from -= 1;
+        }
+        let next = at;
+        while (next < text.length && PATH_CHARACTER.test(text.charAt(next))) {
+            next += 1;
+        }
+        read(from, next);
+        at = text.indexOf(PART, Math.max(next, at + 1));
+    }
+    return { found, unwritten };
+}
+/** Whether `segment` is the text `glob` writes, any text standing between two of its parts. */
+function standsFor(glob, segment) {
+    const first = glob[0] ?? "";
+    const last = glob.at(-1) ?? "";
+    if (glob.length === 1) {
+        return segment === first;
+    }
+    if (!segment.startsWith(first) ||
+        !segment.endsWith(last) ||
+        first.length + last.length > segment.length) {
+        return false;
+    }
+    let at = first.length;
+    const end = segment.length - last.length;
+    for (const middle of glob.slice(1, -1)) {
+        const found = segment.indexOf(middle, at);
+        if (found < 0 || found + middle.length > end) {
+            return false;
+        }
+        at = found + middle.length;
+    }
+    return true;
+}
+/** Whether a word's glob may write `path` or the end of it after a `/`. */
+function mayStandFor(glob, path) {
+    let at = 0;
+    while (!standsFor(glob, path.slice(at))) {
+        const slash = path.indexOf("/", at);
+        if (slash < 0) {
+            return false;
+        }
+        at = slash + 1;
+    }
+    return true;
 }
 /**
- * Every file of `files` below `dir` that `text` names: one whose {@link stemsOf} a path of it
- * spells appears anywhere in the text. A file the text does not name may be held too, and no
- * file it names is missed.
+ * Each spelling of one path below `dir` a word may write the end of: the whole path from `root`,
+ * so a word may write the directories between them too, but no checkout's own, without its
+ * extension, and without its `/index` part, which alone is a directory's spelling.
  */
-export function spelledFiles(text, dir, files) {
-    const byStem = new Map();
+function spellingsBelow(path, dir, root) {
+    const fromRoot = relativePath(root, path);
+    if (relativePath(dir, path) === undefined || fromRoot === undefined) {
+        return { file: [], directory: [] };
+    }
+    const whole = `/${fromRoot}`;
+    const extension = extensionOf(whole, NAMED_EXTENSIONS);
+    const bare = extension === undefined ? whole : whole.slice(0, -extension.length);
+    const directory = bare.endsWith("/index") ? [bare.slice(0, -"/index".length)] : [];
+    return { file: [whole, bare, ...directory], directory };
+}
+/**
+ * Every file of `files` below `dir` that `words` name: one of whose {@link namesOf} a path of it
+ * has appears in a word as a path, or a spelling of one of whose paths a word that writes a
+ * path with a part only its run knows may stand for, and whether a word that may write the
+ * file a command runs writes no path text. A file the words do not name may be named too, and
+ * no file a word writes as a path outside an image's or a package's name is missed.
+ */
+export function spelledFiles(words, dir, root, files) {
+    const byName = new Map();
     for (const { file, paths } of files) {
         const [own] = paths;
         if (own === undefined || relativePath(dir, own) === undefined) {
             continue;
         }
-        for (const stem of new Set(paths.flatMap((path) => stemsOf(path, dir)))) {
-            byStem.set(stem, [...(byStem.get(stem) ?? []), file]);
+        const seen = new Set();
+        for (const name of paths.flatMap((path) => namesOf(path, dir))) {
+            const key = `${name.kind}\u0000${name.text}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                byName.set(name.text, [...(byName.get(name.text) ?? []), { file, name }]);
+            }
         }
     }
     const found = new Set();
-    // One pass per stem length: each place of the text is looked up once for every length.
-    for (const length of new Set([...byStem.keys()].map((stem) => stem.length))) {
+    const text = words.map((word) => word.text).join("\n");
+    const ruledOut = placesNamingNoFile(text);
+    // One pass per name length: each place of the text is looked up once for every length.
+    for (const length of new Set([...byName.keys()].map((name) => name.length))) {
         for (let at = 0; at + length <= text.length; at += 1) {
-            byStem.get(text.slice(at, at + length))?.forEach((file) => found.add(file));
+            for (const { file, name } of byName.get(text.slice(at, at + length)) ?? []) {
+                if (!found.has(file) && ruledOut[at] !== 1 && appearsAsPath(text, at, name)) {
+                    found.add(file);
+                }
+            }
         }
     }
-    return [...found];
+    const dynamic = [];
+    let unwritten = false;
+    let start = 0;
+    const depth = normalizePath(dir) === normalizePath(root)
+        ? 0
+        : (relativePath(root, dir)?.split("/").length ?? 0);
+    for (const word of words) {
+        const read = dynamicWords(word, start, ruledOut, depth);
+        dynamic.push(...read.found);
+        unwritten ||= read.unwritten;
+        start += word.text.length + 1;
+    }
+    if (dynamic.length > 0) {
+        for (const { file, paths } of files) {
+            const spellings = paths.map((path) => spellingsBelow(path, dir, root));
+            if (!found.has(file) &&
+                dynamic.some((word) => spellings.some((spelled) => (word.directory ? spelled.directory : spelled.file).some((one) => mayStandFor(word.glob, one))))) {
+                found.add(file);
+            }
+        }
+    }
+    return { files: [...found], unwritten };
 }
-/** A character a package's or a command's name may hold, so one beside a name makes it part of a longer one. */
-const NAME_CHARACTER = /[\w.@-]/u;
 /**
  * Each of `names`, a package's or a command's name, that `text` holds with no name character
  * before it and no character after it but one a path or a version may go on with, `/`, `.` or

package/dist/src/verbs/analyze.js

@@ -98,13 +98,28 @@ function unseenLoadNotes(loads) {
 /** One note per package whose command strings name files a configuration holds, naming every such file. */
 function heldScriptNotes(held, targetRoot) {
     const files = new Map();
+    const unwritten = new Set();
     for (const one of held) {
         files.set(one.dir, new Set([...(files.get(one.dir) ?? []), ...one.files]));
+        if (one.unwritten) {
+            unwritten.add(one.dir);
+        }
     }
     return [...files].map(([dir, paths]) => ({
         kind: "unread-command",
         path: relativePath(targetRoot, dir) ?? ".",
-        message: `commands the analysis does not read name ${[...paths].sort(bytewise).join(", ")}, so no finding is reported about ${paths.size === 1 ? "that file itself or the names it exports" : "those files themselves or the names they export"}`,
+        message: [
+            ...(paths.size === 0
+                ? []
+                : [
+                    `commands the analysis does not read name ${[...paths].sort(bytewise).join(", ")}, so no finding is reported about ${paths.size === 1 ? "that file itself or the names it exports" : "those files themselves or the names they export"}`,
+                ]),
+            ...(unwritten.has(dir)
+                ? [
+                    "a command runs a file whose path no word of it writes, so a finding that a file of the package is never built or never imported is possible at most",
+                ]
+                : []),
+        ].join("; "),
     }));
 }
 function unresolvedNotes(specifiers) {