@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.1

package/dist/src/workflow-steps.js

@@ -1,18 +1,33 @@
 /**
- * The source files a CI workflow's `run:` steps name by their path from the target root.
- * A workflow file is read as text, line by line, with no YAML parsed.
+ * The source files a CI workflow's `run:` steps and the repository's git hooks name by their
+ * path from the target root. A workflow or hook file is read as text, line by line, with no
+ * YAML parsed.
  */
 import { scriptTokens } from "./manifest.js";
-import { joinPath, resolvePath } from "./paths.js";
+import { joinPath, relativePath, resolvePath } from "./paths.js";
 const WORKFLOWS = ".github/workflows";
 /** A line holding a run command: indentation and one sequence marker before `run:`. */
 const RUN_LINE = /^(\s*(?:- )?)run:(.*)$/u;
+/** The directories whose every file is a git hook script, run as the shell runs it. */
+const HOOK_DIRS = [".husky", ".githooks"];
+/** The hook manager files whose commands are written under a key, with that key. */
+const HOOK_MANAGERS = [
+    [".pre-commit-config.yaml", /^(\s*(?:- )?)entry:(.*)$/u],
+    ["lefthook.yml", RUN_LINE],
+    ["lefthook.yaml", RUN_LINE],
+    [".lefthook.yml", RUN_LINE],
+];
+/** The names GNU make reads a makefile under, in the order it tries them. */
+const MAKEFILES = ["GNUmakefile", "makefile", "Makefile"];
+/** The operators that end one shell command of a recipe line. */
+const COMMAND_SEPARATORS = /&&|\|\||;|\|/u;
 const BLOCK_SCALAR = /^[|>][+-]?$/u;
 const QUOTED = /^(["'])(.*)\1$/su;
 /** A token holding one of these is computed or a pattern, so it names no file. */
 const COMPUTED = /[${*?[]/u;
 const INDENT = /^\s*/u;
-function workflowFiles(host, dir) {
+/** The files directly in one directory whose name `accepts`, in name order. */
+function filesIn(host, dir, accepts) {
     let entries;
     try {
         entries = host.readDirectory(dir);
@@ -21,16 +36,24 @@ function workflowFiles(host, dir) {
         return [];
     }
     return entries
-        .filter((entry) => !entry.directory && /\.ya?ml$/u.test(entry.name))
+        .filter((entry) => !entry.directory && accepts(entry.name))
         .map((entry) => joinPath(dir, entry.name))
         .sort();
 }
-/** Every command line one workflow file's `run:` steps hold. */
-export function runCommands(text) {
+function readText(host, path) {
+    try {
+        return host.readFile(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Every command line one workflow file's `run:` steps, or the steps under `key`, hold. */
+export function runCommands(text, key = RUN_LINE) {
     const lines = text.split(/\r?\n/u);
     const found = [];
     for (let at = 0; at < lines.length; at += 1) {
-        const match = RUN_LINE.exec(lines[at] ?? "");
+        const match = key.exec(lines[at] ?? "");
         if (match === null) {
             continue;
         }
@@ -50,28 +73,92 @@ export function runCommands(text) {
     }
     return found;
 }
-/** Every token the `run:` steps of the workflow files in the target root's `.github/workflows` hold. */
-export function workflowTokens(host, targetRoot) {
-    const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
+/**
+ * Every token the recipe lines of the target root's makefile hold, each with the directory
+ * below the root it is read against: a recipe line is one that starts with a tab, joined
+ * with the lines a trailing `\` continues it onto, and make runs each in a shell of its
+ * own, so a `cd` moves the directory of the later commands of its line alone.
+ */
+function recipeTokens(host, root) {
+    const path = MAKEFILES.map((name) => joinPath(root, name)).find((candidate) => host.kindOf(candidate) === "file");
+    const text = path === undefined ? undefined : readText(host, path);
+    if (text === undefined) {
+        return [];
+    }
     const found = [];
-    for (const path of workflowFiles(host, dir)) {
-        let text;
-        try {
-            text = host.readFile(path);
-        }
-        catch {
+    for (const line of text.replace(/\\\r?\n/gu, " ").split(/\r?\n/u)) {
+        if (!line.startsWith("\t")) {
             continue;
         }
-        for (const command of runCommands(text)) {
-            found.push(...scriptTokens(command));
+        let dir = root;
+        for (const command of withoutComment(line.slice(1).replace(/^[@+-]+/u, "")).split(COMMAND_SEPARATORS)) {
+            const tokens = scriptTokens(command);
+            const [first, target, ...rest] = tokens;
+            if (first === "cd" && target !== undefined && rest.length === 0 && !COMPUTED.test(target)) {
+                dir = resolvePath(dir, target);
+                continue;
+            }
+            for (const token of tokens) {
+                found.push({ token, dir: relativePath(root, dir) ?? "" });
+            }
         }
     }
     return found;
 }
+/** One shell line up to its comment: a `#` that starts a word outside quotes. */
+function withoutComment(line) {
+    let quote = "";
+    for (let at = 0; at < line.length; at += 1) {
+        const char = line[at];
+        if (quote !== "") {
+            if (char === quote) {
+                quote = "";
+            }
+            else if (char === "\\" && quote === '"') {
+                at += 1;
+            }
+        }
+        else if (char === "'" || char === '"') {
+            quote = char;
+        }
+        else if (char === "\\") {
+            at += 1;
+        }
+        else if (char === "#" && (at === 0 || /\s/u.test(line[at - 1] ?? ""))) {
+            return line.slice(0, at);
+        }
+    }
+    return line;
+}
+/**
+ * Every token the target root's workflow steps, git hooks and makefile hold: the `run:`
+ * steps of the workflow files in `.github/workflows`, every line of each file in `.husky`
+ * and `.githooks`, the `entry:` commands of `.pre-commit-config.yaml`, the `run:` commands
+ * of a lefthook file and the makefile's recipe lines.
+ */
+export function workflowTokens(host, targetRoot) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    const commands = [];
+    for (const path of filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name))) {
+        commands.push(...runCommands(readText(host, path) ?? ""));
+    }
+    for (const dir of HOOK_DIRS) {
+        for (const path of filesIn(host, joinPath(root, dir), () => true)) {
+            commands.push(...(readText(host, path) ?? "").split(/\r?\n/u).map(withoutComment));
+        }
+    }
+    for (const [name, key] of HOOK_MANAGERS) {
+        commands.push(...runCommands(readText(host, joinPath(root, name)) ?? "", key));
+    }
+    return [
+        ...commands.flatMap((command) => scriptTokens(command)),
+        ...recipeTokens(host, root).map(({ token }) => token),
+    ];
+}
 /**
- * The own files the `run:` steps of every workflow file in the target root's
- * `.github/workflows` name: a token equal to a file's path below the target root, with or
- * without a leading `./`, whatever directory the step runs in.
+ * The own files the target root's workflow steps and git hooks name, as
+ * {@link workflowTokens} reads them: a token equal to a file's path below the target root,
+ * with or without a leading `./`, whatever directory the step runs in.
  */
 export function workflowEntries(host, targetRoot, files) {
     const found = [];
@@ -84,5 +171,15 @@ export function workflowEntries(host, targetRoot, files) {
             found.push({ file, source: token });
         }
     }
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    for (const { token, dir } of recipeTokens(host, root)) {
+        const below = COMPUTED.test(token) || dir === ""
+            ? undefined
+            : relativePath(root, resolvePath(joinPath(root, dir), token));
+        const file = below === undefined ? undefined : files.byPath.get(below);
+        if (file !== undefined) {
+            found.push({ file, source: token });
+        }
+    }
     return found;
 }

package/dist/src/workspace-programs.js

@@ -7,18 +7,22 @@
  */
 import { ModuleKind, ModuleResolutionKind } from "@typescript/native/sync";
 import { isStringLiteralLikeNode } from "@typescript/native/ast";
+import { baseUrlPaths } from "./base-url.js";
 import { dirnamePath, resolvePath } from "./paths.js";
 /** The most questions one round trip carries. */
 const BATCH = 2048;
 /**
  * The options a configuration's program is built with: its own, less the ones that
- * lay out an emitted program's inputs and outputs. The analysis emits nothing, and a
+ * lay out an emitted program's inputs and outputs, and with `paths` read against the
+ * effective `baseUrl` as {@link baseUrlPaths} states. The analysis emits nothing, and a
  * member's source is outside the importer's root directory by construction, which
  * the compiler refuses under such a layout.
  */
 function analysisOptions(parsed) {
     const { composite, rootDir: _rootDir, outDir: _outDir, declarationDir: _declarationDir, tsBuildInfoFile: _tsBuildInfoFile, ...kept } = parsed.options;
-    return composite === true ? { ...kept, declaration: true } : kept;
+    const paths = baseUrlPaths(parsed.options);
+    const options = paths === undefined ? kept : { ...kept, paths };
+    return composite === true ? { ...options, declaration: true } : options;
 }
 /** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
 function conditionsOf(parsed, mode) {
@@ -73,7 +77,7 @@ function configurationOf(engine, host, reading) {
     const raw = options["pathsBasePath"];
     const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
     const paths = {};
-    for (const [key, targets] of Object.entries(options.paths ?? {})) {
+    for (const [key, targets] of Object.entries(baseUrlPaths(options) ?? options.paths ?? {})) {
         paths[key] = targets.map((target) => resolvePath(base, target));
     }
     for (const entry of reading.entries) {

package/dist/src/workspace-resolution.js

@@ -1,12 +1,12 @@
 /**
- * Which file an import of a workspace package's name is read from. The package is the
- * one `node_modules` links the importer to or, with no link, the one the importer's
- * manifest depends on. A source file the compiler reaches stands; any other file is read
- * back to the source it is compiled from or to a manifest target that is source, a file
- * the package's configurations neither compile nor write is read as installed, and an
- * import nothing answers for is unresolved.
+ * Which file an import of a workspace package's name is read from: the package
+ * `node_modules` links the importer to or, with no link, the one its manifest depends on.
+ * A source file the compiler reaches stands; any other file reads back to its source or to
+ * a manifest target that is source, an ignored file to the source its path mirrors, a file
+ * the package neither compiles nor writes is read as installed, and the rest is unresolved.
  */
 import { emittedFrom } from "./emit-map.js";
+import { gitIgnored } from "./git-ignore.js";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { satisfies } from "./version-range.js";
 /** The manifest members that name an entry point for the subpath `.` without `exports`. */
@@ -163,6 +163,27 @@ export function workspaceResolver(host, workspace) {
         links.set(key, found);
         return found;
     };
+    const root = workspace.members[0]?.dir;
+    const ignored = root === undefined ? () => false : gitIgnored(host, root);
+    const manifests = new Map();
+    /** The nearest manifest at or above one directory, up to the workspace's root. */
+    const nearestManifest = (dir) => {
+        if (manifests.has(dir)) {
+            return manifests.get(dir);
+        }
+        let found;
+        try {
+            const value = JSON.parse(host.readFile(joinPath(dir, "package.json")));
+            found = isRecord(value) ? { dir, manifest: value } : undefined;
+        }
+        catch {
+            const up = dirnamePath(dir);
+            found =
+                up === dir || root === undefined || !inside(root, up) ? undefined : nearestManifest(up);
+        }
+        manifests.set(dir, found);
+        return found;
+    };
     const linkOf = (candidates, fromDir) => {
         const name = candidates[0]?.name ?? "";
         const linked = linkedFrom(name, fromDir);
@@ -174,13 +195,15 @@ export function workspaceResolver(host, workspace) {
         if (scope?.name === name) {
             return { kind: "member", member: scope };
         }
-        const manifest = scope?.manifest;
+        // A package below the root that no workspace lists depends on a member as a member does.
+        const owner = scope ?? nearestManifest(fromDir);
+        const manifest = owner?.manifest;
         const declared = DEPENDENCY_MEMBERS.flatMap((field) => {
             const held = manifest?.[field];
             const specifier = isRecord(held) ? held[name] : undefined;
             return typeof specifier === "string" ? [specifier] : [];
         });
-        const matched = candidates.filter((member) => declared.some((specifier) => dependsOn(specifier, member, scope?.dir ?? fromDir)));
+        const matched = candidates.filter((member) => declared.some((specifier) => dependsOn(specifier, member, owner?.dir ?? fromDir)));
         const [one, two] = matched;
         if (one === undefined) {
             return { kind: "none" };
@@ -191,6 +214,21 @@ export function workspaceResolver(host, workspace) {
     };
     /** The files a member's configurations compile, which is what makes a file there source. */
     const compiled = (member, path) => member.configurations.some((configuration) => configuration.fileNames.has(path));
+    /**
+     * The member's source an ignored output path mirrors: the path below one of its
+     * directories, the deepest first, read below the member's own directory as an output
+     * directory's tree mirrors its root directory's, which a build leaves in an ignored
+     * directory however its configuration writes it.
+     */
+    const mirrored = (member, path) => {
+        for (let dir = dirnamePath(path); inside(member.dir, dir); dir = dirnamePath(dir)) {
+            const found = emittedFrom(path, { outDir: dir, sourceDirs: [member.dir] }).find((candidate) => SOURCE.test(candidate) && !ignored(candidate) && host.kindOf(candidate) === "file");
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        return undefined;
+    };
     /**
      * The member's source one of its paths is, or is compiled from: a TypeScript source
      * file, the source an output path maps back to, or a file one of the member's
@@ -212,6 +250,9 @@ export function workspaceResolver(host, workspace) {
         if (found !== undefined) {
             return found;
         }
+        if (ignored(path)) {
+            return mirrored(member, path);
+        }
         return compiled(member, path) && host.kindOf(path) === "file" ? path : undefined;
     };
     /** The targets a member's manifest names for one subpath, the selected one first. */
@@ -270,9 +311,11 @@ export function workspaceResolver(host, workspace) {
             }
             const { member } = linked;
             // A member no compiler configuration builds is read as the package manager
-            // installed it, wherever the compiler's resolution found it.
+            // installed it, wherever the compiler's resolution found it, unless what it found is
+            // a file the tree ignores, which no install wrote.
             if (answered !== undefined &&
-                (member.configurations.length === 0 || !inside(member.dir, answered.resolvedFileName))) {
+                ((member.configurations.length === 0 && !ignored(answered.resolvedFileName)) ||
+                    !inside(member.dir, answered.resolvedFileName))) {
                 return { kind: "default" };
             }
             if (answered !== undefined) {

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.2.0-dev.4",
+  "version": "8.0.0-dev.1",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.2.0-dev.4",
+  "version": "8.0.0-dev.1",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -43,7 +43,7 @@
     "@types/node": "24.19.2",
     "eslint": "10.12.0",
     "fast-check": "4.10.2",
-    "prettier": "3.9.9",
+    "prettier": "3.9.10",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "typescript-eslint": "8.71.1",
     "vitest": "5.0.4"

package/src/analysis.ts

@@ -6,6 +6,7 @@
  * another project's checker, which holds only for views the session hands out.
  */
 
+import { isStringLiteralLikeNode } from "@typescript/native/ast";
 import { lineOf, readComponent } from "./component-files.ts";
 import { kindOf, type Config, type Provenance } from "./config.ts";
 import {
@@ -26,9 +27,11 @@ import {
   discoverProjects,
   DiscoveryError,
   isGuess,
+  MISSING_GLOBAL_TYPE,
   projectErrors,
   renderDiagnostic,
   targetRelative,
+  withBaseUrlPaths,
   type LocatedDiagnostic,
   type NotBuilt,
 } from "./discover.ts";
@@ -70,7 +73,7 @@ import { injectionContainer } from "./injection-container.ts";
 import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.ts";
 import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
 import { inventory, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { packageEntries, readManifest } from "./manifest.ts";
+import { packageEntries, readManifest, type ManifestEntry } from "./manifest.ts";
 import {
   liveFilesAt,
   matrixOf,
@@ -112,7 +115,7 @@ import type { Scope } from "./scope.ts";
 import { serializationContract } from "./serialization-contract.ts";
 import { outsideTestReferences, testFilesAt, type OutsideTest } from "./outside-tests.ts";
 import { joinedTestFiles, withJoinedTests } from "./test-joins.ts";
-import { supportReferences, testSupportFiles } from "./test-support.ts";
+import { supportReferences, testSupportFiles, type TestEvidence } from "./test-support.ts";
 import {
   diagnosticsOf,
   ownedAs,
@@ -390,6 +393,11 @@ function readProjects<Answer>(
       publishedMembers: new Set(
         (workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir),
       ),
+      runFiles: new Set(
+        opened.flatMap((one) =>
+          one.fileNames().map((name) => resolvePath(host.workingDirectory(), name)),
+        ),
+      ),
     };
   };
   const notBuilt: NotBuilt[] = [...discovered.notBuilt];
@@ -420,6 +428,12 @@ function readProjects<Answer>(
   const joins = discovered.derived
     ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
     : new Map<string, readonly string[]>();
+  const programs = withBaseUrlPaths(
+    engine,
+    host,
+    [...discovered.configFiles, ...consumerOf.keys()],
+    workspace?.programs ?? new Map(),
+  );
   const session = runSession(
     engine,
     [...discovered.configFiles, ...consumerOf.keys()],
@@ -514,11 +528,29 @@ function readProjects<Answer>(
           error: renderDiagnostic(one, (path) => relativePath(absoluteRoot, path) ?? path),
         })),
       );
+      const missingGlobal = raw.unfound.find(
+        ({ diagnostic }) => diagnostic.code === MISSING_GLOBAL_TYPE,
+      );
+      const skips =
+        missingGlobal === undefined
+          ? reading.skips
+          : [
+              ...reading.skips,
+              ...project.ownSourceFiles().map((file) => ({
+                record: {
+                  path: relativePath(absoluteRoot, file.fileName) ?? file.fileName,
+                  line: 1,
+                  message: missingGlobal.diagnostic.text,
+                },
+                file,
+                unit: file,
+              })),
+            ];
       const configuration = ids.get(project.configFile) ?? project.configFile;
       const read = (): ProjectRead => {
         const held = inventory(project, host, targetRoot);
         const found = roots(project, held, targetRoot, options);
-        const kept = skippedRoots(project, held, reading.skips);
+        const kept = skippedRoots(project, held, skips);
         const rooted =
           kept.length === 0
             ? found
@@ -535,8 +567,8 @@ function readProjects<Answer>(
           configFile: project.configFile,
           held,
           rooted,
-          typeErrorSkips: reading.skips.map((one) => one.record),
-          skipped: skippedUnits(reading.skips, absoluteRoot),
+          typeErrorSkips: skips.map((one) => one.record),
+          skipped: skippedUnits(skips, absoluteRoot),
           referenceOnly: project
             .ownSourceFiles()
             .filter((file) => referenceOnly(file.fileName))
@@ -551,9 +583,7 @@ function readProjects<Answer>(
       return stage(project, { configuration, read });
     },
     discovered.derived ? "record" : "refuse",
-    joins.size === 0
-      ? workspace?.programs
-      : withJoinedTests(engine, host, workspace?.programs ?? new Map(), joins),
+    joins.size === 0 ? programs : withJoinedTests(engine, host, programs, joins),
     () => {
       outsideTests = testFilesAt(
         host,
@@ -759,6 +789,8 @@ interface SweptProject<Extra> {
   /** The component files the project holds of its own, by path below the target root. */
   readonly componentFiles: readonly string[];
   readonly componentWarnings: readonly ComponentWarning[];
+  /** The manifest entries the project reads back to no file of its own. */
+  readonly unmappedEntries: readonly ManifestEntry[];
   readonly extra: Extra;
 }
 
@@ -770,6 +802,8 @@ interface ReadProject<Extra> {
   readonly evidence: readonly Exemption[];
   readonly componentFiles: readonly string[];
   readonly componentWarnings: readonly ComponentWarning[];
+  /** Per own file below the target root, the module specifiers its imports write. */
+  readonly imports: ReadonlyMap<string, readonly string[]>;
   readonly extra: Extra;
 }
 
@@ -800,6 +834,64 @@ interface ReadRun<Extra> {
   readonly nestedDirs: readonly string[];
 }
 
+/** The manifest section of a package test evidence counts, and the sections that keep one out of it. */
+const DEV_SECTION = "devDependencies";
+const OTHER_SECTIONS = ["dependencies", "peerDependencies", "optionalDependencies"] as const;
+
+/**
+ * The imports of a run's own files and the manifests below the target root that test
+ * evidence reads: a package is a devDependency of a file where the nearest manifest at or
+ * above it that declares the package declares it under `devDependencies` alone.
+ */
+function testEvidence(
+  host: Host,
+  targetRoot: string,
+  projects: readonly { readonly imports: ReadonlyMap<string, readonly string[]> }[],
+): TestEvidence {
+  const imports = new Map<string, readonly string[]>();
+  for (const one of projects) {
+    for (const [path, specifiers] of one.imports) {
+      imports.set(path, specifiers);
+    }
+  }
+  const manifests = new Map<string, Readonly<Record<string, unknown>> | undefined>();
+  const manifestAt = (dir: string): Readonly<Record<string, unknown>> | undefined => {
+    if (!manifests.has(dir)) {
+      let value: unknown;
+      try {
+        value = JSON.parse(host.readFile(joinPath(dir, "package.json")));
+      } catch {
+        value = undefined;
+      }
+      manifests.set(
+        dir,
+        typeof value === "object" && value !== null && !Array.isArray(value)
+          ? (value as Record<string, unknown>)
+          : undefined,
+      );
+    }
+    return manifests.get(dir);
+  };
+  const declares = (section: unknown, name: string): boolean =>
+    typeof section === "object" && section !== null && Object.hasOwn(section, name);
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  return {
+    imports,
+    devDependency: (path, name) => {
+      for (let dir = dirnamePath(joinPath(root, path)); ; dir = dirnamePath(dir)) {
+        const manifest = manifestAt(dir);
+        const other = OTHER_SECTIONS.some((one) => declares(manifest?.[one], name));
+        if (declares(manifest?.[DEV_SECTION], name) || other) {
+          return !other;
+        }
+        if (normalizePath(dir) === normalizePath(root) || dirnamePath(dir) === dir) {
+          return false;
+        }
+      }
+    },
+  };
+}
+
 /**
  * Reads every project of the run, its references and exemptions, and `extra`'s answer,
  * while the project's view is open, and merges the projects into one matrix in the run's
@@ -856,6 +948,14 @@ function readRun<Extra>(
       testFiles: resolved.testFilePaths,
       evidence,
       componentFiles: components.map(pathOf),
+      imports: new Map(
+        project.ownSourceFiles().flatMap((file) => {
+          const path = relativePath(targetRoot, file.fileName);
+          return path === undefined
+            ? []
+            : [[path, file.imports.filter(isStringLiteralLikeNode).map((one) => one.text)]];
+        }),
+      ),
       componentWarnings: components.flatMap((file) =>
         readComponent(file.originalText, extensionOf(file.fileName)).warnings.map((warning) => ({
           path: pathOf(file),
@@ -882,6 +982,7 @@ function readRun<Extra>(
     withOutside.flatMap((one) => one.references),
     withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability),
     withOutside.flatMap((one) => one.testFiles),
+    testEvidence(host, targetRoot, withOutside),
   );
   const settled = settledSatisfaction(
     withOutside.map((one) => ({ evidence: one.evidence, held: one.projectRead.held })),
@@ -903,8 +1004,9 @@ function readRun<Extra>(
       symbols: projectRead.held.symbols,
       references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
       roots: projectRead.rooted.liveUnderReachability,
-      testFiles: one.testFiles,
+      testFiles: [...one.testFiles, ...supportFiles],
       ...(supportFiles.length === 0 ? {} : { supportFiles }),
+      ...(projectRead.held.ambient.size === 0 ? {} : { ambient: projectRead.held.ambient }),
       ...(projectRead.referenceOnly.length === 0
         ? {}
         : { referenceOnly: projectRead.referenceOnly }),
@@ -925,6 +1027,7 @@ function readRun<Extra>(
         ...exempt.filter(isUnansweredRecord).map((record) => record.id),
       ],
       typeErrorSkips: projectRead.typeErrorSkips,
+      unmappedEntries: projectRead.rooted.unmappedEntries,
       skipped: projectRead.skipped,
       componentFiles: one.componentFiles,
       componentWarnings: one.componentWarnings,
@@ -1190,7 +1293,8 @@ export function readEmitterRun(
  * The workspace members whose dependencies the run judges: `read` holds those a built
  * project holds a file below, `unbuilt` the others whose own directory, the nearest
  * manifest's above the configuration, holds a configuration the run could not build. A
- * member no configuration holds a file of is in neither.
+ * member no configuration holds a file of is in neither. A nested package no built project
+ * holds a file below joins `unbuilt` the same way.
  */
 function judgedMembers(
   host: Host,
@@ -1214,6 +1318,16 @@ function judgedMembers(
       judged.unbuilt.push(dir);
     }
   }
+  for (const dir of read.nestedDirs) {
+    const below = relativePath(root, dir);
+    if (
+      below !== undefined &&
+      owners.has(dir) &&
+      ![...held].some((path) => path.startsWith(`${below}/`))
+    ) {
+      judged.unbuilt.push(dir);
+    }
+  }
   return judged;
 }
 
@@ -1359,6 +1473,7 @@ function readAnalysis(
       componentsUnread: read.componentsUnread,
       librariesUnfound: read.librariesUnfound,
       conventionsApplied: read.conventionsApplied,
+      unmappedEntries: unmappedEverywhere(read.projects),
     },
     configured: read.projects.map((one) => one.configured),
     symbols,
@@ -1410,6 +1525,22 @@ function inputsOver(
   };
 }
 
+/** The manifest entries every project of the run reads back to no file, in the first project's order. */
+function unmappedEverywhere(
+  projects: readonly { readonly unmappedEntries: readonly ManifestEntry[] }[],
+): readonly ManifestEntry[] {
+  const key = (entry: ManifestEntry): string => `${entry.dir}\u0000${entry.member}`;
+  const [first, ...rest] = projects;
+  const others = rest.map((one) => new Set(one.unmappedEntries.map(key)));
+  const found = new Map<string, ManifestEntry>();
+  for (const entry of first?.unmappedEntries ?? []) {
+    if (others.every((one) => one.has(key(entry)))) {
+      found.set(key(entry), entry);
+    }
+  }
+  return [...found.values()];
+}
+
 /** One project of a run: the name the run gives it and the file it was opened from. */
 export interface RunProject {
   readonly id: string;
@@ -1439,6 +1570,8 @@ interface RunFacts {
   readonly librariesUnfound: readonly LibraryUnfound[];
   /** The convention rows the run applied. */
   readonly conventionsApplied: readonly AppliedConvention[];
+  /** The manifest entries no project of the run reads back to a file, each once. */
+  readonly unmappedEntries: readonly ManifestEntry[];
 }
 
 /** One configuration whose component files a run cannot read. */