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

package/src/type-parameter-reads.ts

@@ -0,0 +1,227 @@
+/**
+ * The members a read through a value typed by a type parameter reaches: `value.kind`,
+ * where `value` is of a type parameter `T` of a generic function, reads `kind` on each
+ * object type no class declares that a call of the function passes for `T`, because the
+ * call's value is what the read reads, whatever member of the constraint the name resolves
+ * to. A class's members a constraint requires are interface satisfaction's.
+ */
+
+import {
+  isBinaryExpression,
+  isCallExpression,
+  isIdentifier,
+  isNewExpression,
+  isPropertyAccessExpression,
+  isTypeParameterDeclaration,
+  SyntaxKind,
+  type CallExpression,
+  type NewExpression,
+  type Node,
+  type PropertyAccessExpression,
+  type SourceFile,
+} from "@typescript/native/ast";
+import { SymbolFlags, type Type } from "@typescript/native/sync";
+import type { AliasChains } from "./alias-chain.ts";
+import { nodeKey, type Inventory } from "./inventory.ts";
+import { renderPosition } from "./position.ts";
+import { isAnswered } from "./query.ts";
+import type { Reference } from "./references.ts";
+import type { ProjectView } from "./session.ts";
+
+/** How deep a parameter's type is matched against the type a call passes: `readonly T[]` is one level. */
+const MATCH_DEPTH = 3;
+
+/** One read of a member through a value whose type is a type parameter. */
+interface Read {
+  readonly file: SourceFile;
+  readonly from: string;
+  readonly access: PropertyAccessExpression;
+}
+
+/** A node that declares parameters, as a generic function does. */
+type Generic = Node & {
+  readonly parameters?: readonly Node[];
+};
+
+/** The name a call reaches one generic by: its own, or that of what holds it. */
+function nameOf(generic: Generic): string | undefined {
+  const own = (generic as { readonly name?: Node }).name;
+  const holder = (generic.parent as { readonly name?: Node } | undefined)?.name;
+  const name = own ?? holder;
+  return name !== undefined && isIdentifier(name) ? name.text : undefined;
+}
+
+/** Whether a property access is the target of a plain assignment, which writes the member. */
+function assignedTo(access: PropertyAccessExpression): boolean {
+  const parent = access.parent;
+  return (
+    isBinaryExpression(parent) &&
+    parent.operatorToken.kind === SyntaxKind.EqualsToken &&
+    parent.left === access
+  );
+}
+
+/**
+ * The references the reads through type-parameter-typed values of one project's own files
+ * make to the members of the types its calls pass, each made by the declaration holding
+ * the read.
+ */
+export function typeParameterReads<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  chains: AliasChains,
+  root: string,
+  testFiles: ReadonlySet<string>,
+): readonly Reference[] {
+  const queries = project.queries;
+  const reads: Read[] = [];
+  const calls: (CallExpression | NewExpression)[] = [];
+  for (const file of project.ownSourceFiles()) {
+    const fileId = held.declarations.get(nodeKey(file, file));
+    if (fileId === undefined) {
+      continue;
+    }
+    const visit = (node: Node, from: string, generic: boolean): void => {
+      const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+      const inside =
+        generic ||
+        (node as { readonly typeParameters?: readonly Node[] }).typeParameters !== undefined;
+      if (
+        inside &&
+        isPropertyAccessExpression(node) &&
+        isIdentifier(node.name) &&
+        !assignedTo(node)
+      ) {
+        reads.push({ file, from: holder, access: node });
+      }
+      if (isCallExpression(node) || isNewExpression(node)) {
+        calls.push(node);
+      }
+      node.forEachChild((child) => {
+        visit(child, holder, inside);
+      });
+    };
+    file.forEachChild((child) => {
+      visit(child, fileId, false);
+    });
+  }
+  if (reads.length === 0) {
+    return [];
+  }
+
+  // The reads whose receiver the checker types as a type parameter, by the generic declaring it.
+  const receivers = queries.typesAt(reads.map((read) => read.access.expression));
+  const byGeneric = new Map<Generic, { read: Read; parameter: Type }[]>();
+  reads.forEach((read, at) => {
+    const type = receivers[at];
+    if (type === undefined || !isAnswered(type) || !type.isTypeParameter()) {
+      return;
+    }
+    const symbol = queries.symbolOfType(type);
+    const declaration =
+      symbol === undefined || !isAnswered(symbol)
+        ? undefined
+        : symbol.declarations
+            .map((handle) => project.declarationAt(handle)?.node)
+            .find((node) => node !== undefined && isTypeParameterDeclaration(node));
+    const generic = declaration?.parent as Generic | undefined;
+    if (generic !== undefined) {
+      byGeneric.set(generic, [...(byGeneric.get(generic) ?? []), { read, parameter: type }]);
+    }
+  });
+  if (byGeneric.size === 0) {
+    return [];
+  }
+
+  /** The types `instantiated` holds where `declared` holds `parameter`, matched part for part. */
+  const passedFor = (
+    parameter: Type,
+    declared: Type,
+    instantiated: Type,
+    depth: number,
+  ): readonly Type[] => {
+    if (declared.id === parameter.id) {
+      return [instantiated];
+    }
+    if (depth >= MATCH_DEPTH) {
+      return [];
+    }
+    const a = queries.typeArguments(declared);
+    const b = queries.typeArguments(instantiated);
+    if (!isAnswered(a) || !isAnswered(b) || a.length !== b.length) {
+      return [];
+    }
+    return a.flatMap((one, at) => {
+      const other = b[at];
+      return other === undefined ? [] : passedFor(parameter, one, other, depth + 1);
+    });
+  };
+
+  // Only a call spelling a generic's name is resolved: one request each.
+  const spelled = new Set([...byGeneric.keys()].flatMap((generic) => nameOf(generic) ?? []));
+  const found = new Map<string, Reference>();
+  for (const call of calls) {
+    const callee = call.expression;
+    const written = isIdentifier(callee)
+      ? callee.text
+      : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
+        ? callee.name.text
+        : undefined;
+    if (written === undefined || !spelled.has(written)) {
+      continue;
+    }
+    const resolved = queries.resolvedSignature(call);
+    if (resolved === undefined || !isAnswered(resolved) || resolved.declaration === undefined) {
+      continue;
+    }
+    const generic = project.declarationAt(resolved.declaration)?.node as Generic | undefined;
+    const pending = generic === undefined ? undefined : byGeneric.get(generic);
+    const declared = pending === undefined ? undefined : queries.genericOf(resolved);
+    if (pending === undefined || declared === undefined || !isAnswered(declared)) {
+      continue;
+    }
+    const count = (generic?.parameters ?? []).length;
+    for (const { read, parameter } of pending) {
+      const passed: Type[] = [];
+      for (let at = 0; at < count; at += 1) {
+        const own = queries.parameterType(declared, at);
+        const given = queries.typeAtPosition(resolved, at);
+        if (own !== undefined && isAnswered(own) && isAnswered(given)) {
+          passed.push(...passedFor(parameter, own, given, 0));
+        }
+      }
+      const name = read.access.name.text;
+      const position = renderPosition(read.file, root, read.access.name.getStart());
+      for (const type of passed) {
+        const parts = type.isUnionType() ? queries.constituents(type) : [type];
+        for (const part of isAnswered(parts) ? parts : []) {
+          const owner = queries.symbolOfType(part);
+          if (
+            !isAnswered(owner) ||
+            owner === undefined ||
+            (owner.flags & SymbolFlags.Class) !== 0
+          ) {
+            continue;
+          }
+          const properties = queries.propertiesOf(part);
+          for (const property of isAnswered(properties) ? properties : []) {
+            if (property.name !== name) {
+              continue;
+            }
+            for (const to of chains.declarationsOf(property)) {
+              found.set(`${read.from}\u0000${to}\u0000${String(read.access.name.pos)}`, {
+                from: read.from,
+                to,
+                position,
+                use: "read",
+                resolution: "batch",
+                test: testFiles.has(position.path),
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return [...found.values()];
+}

package/src/verbs/analyze.ts

@@ -12,6 +12,7 @@ import { moduleIdentity } from "../consumers.ts";
 import { analyzerProvenance, verdictOf } from "../findings-pass.ts";
 import { joinPath, normalizePath, relativePath, resolvePath } from "../paths.ts";
 import type { Host } from "../host.ts";
+import type { ManifestEntry } from "../manifest.ts";
 import type { NotBuilt } from "../discover.ts";
 import { partialNotes } from "../partial.ts";
 import {
@@ -22,6 +23,7 @@ import {
   type Report,
   type ReportConfiguration,
   type ReportNotBuilt,
+  type ReportNote,
 } from "../report.ts";
 import { json } from "../reporters/json.ts";
 import { RENDERINGS } from "../reporters/reporters.ts";
@@ -92,6 +94,25 @@ function runRelative(invoked: string, path: string): string {
   return below;
 }
 
+/**
+ * One note per manifest entry the run reads back to no source file: what the entry names
+ * reaches nothing, so the findings its file would have rooted are reported.
+ */
+function unmappedNotes(
+  entries: readonly ManifestEntry[],
+  targetRoot: string,
+): readonly ReportNote[] {
+  return entries.map((entry) => {
+    const named = relativePath(targetRoot, entry.path) ?? entry.path;
+    return {
+      kind: "unmapped-entry",
+      path: relativePath(targetRoot, entry.dir) ?? ".",
+      key: "ts.entry_files",
+      message: `the manifest's ${entry.member} names ${named}, which reads back to no source file of the target: name the file it is built from in ts.entry_files`,
+    };
+  });
+}
+
 /** Each project the run dropped as a report names it, by its configuration file below the target. */
 function notBuiltOf(dropped: readonly NotBuilt[], targetRoot: string): readonly ReportNotBuilt[] {
   return dropped.map((one) => {
@@ -288,6 +309,7 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       typeErrorSkips: run.typeErrorSkips,
       unanswered: unansweredCounts(analysis),
       conventionsApplied: run.conventionsApplied,
+      notes: unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
     });
     report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
     verdict = verdictOf(result, config);

package/src/verbs/explain.ts

@@ -315,12 +315,15 @@ function reported(found: CompletedFinding): string {
 /**
  * Every finding of the run that names the declaration by its reference and reports at
  * another position: a part of it, or a suppression record naming it. Each is published under
- * the reference asked about, so an explanation leaving it out would disagree with the report.
+ * the reference asked about, or a parameter's under one it starts, so an explanation leaving
+ * it out would disagree with the report.
  */
 function namedElsewhere(findings: readonly CompletedFinding[], subject: InventorySymbol): string {
   return findings
     .filter(
-      (found) => found.symbol.ref === subject.ref && positionKey(found.position) !== subject.id,
+      (found) =>
+        (found.symbol.holder ?? found.symbol.ref) === subject.ref &&
+        positionKey(found.position) !== subject.id,
     )
     .map(
       (found) =>

package/src/version.ts

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "7.2.0";
+export const CONTRACT_VERSION = "8.0.0";

package/src/workflow-steps.ts

@@ -1,12 +1,13 @@
 /**
- * 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 type { SourceFile } from "@typescript/native/ast";
 import type { Host } from "./host.ts";
 import { scriptTokens } from "./manifest.ts";
-import { joinPath, resolvePath } from "./paths.ts";
+import { joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { SourceFiles } from "./source-files.ts";
 
 /** One file a workflow step names. */
@@ -21,6 +22,23 @@ 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"] as const;
+
+/** The hook manager files whose commands are written under a key, with that key. */
+const HOOK_MANAGERS: readonly (readonly [string, RegExp])[] = [
+  [".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"] as const;
+
+/** The operators that end one shell command of a recipe line. */
+const COMMAND_SEPARATORS = /&&|\|\||;|\|/u;
+
 const BLOCK_SCALAR = /^[|>][+-]?$/u;
 
 const QUOTED = /^(["'])(.*)\1$/su;
@@ -30,7 +48,8 @@ const COMPUTED = /[${*?[]/u;
 
 const INDENT = /^\s*/u;
 
-function workflowFiles(host: Host, dir: string): readonly string[] {
+/** The files directly in one directory whose name `accepts`, in name order. */
+function filesIn(host: Host, dir: string, accepts: (name: string) => boolean): readonly string[] {
   let entries;
   try {
     entries = host.readDirectory(dir);
@@ -38,17 +57,25 @@ function workflowFiles(host: Host, dir: string): readonly string[] {
     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: string): readonly string[] {
+function readText(host: Host, path: string): string | undefined {
+  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: string, key: RegExp = RUN_LINE): readonly string[] {
   const lines = text.split(/\r?\n/u);
   const found: string[] = [];
   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;
     }
@@ -69,28 +96,95 @@ export function runCommands(text: string): readonly string[] {
   return found;
 }
 
-/** Every token the `run:` steps of the workflow files in the target root's `.github/workflows` hold. */
-export function workflowTokens(host: Host, targetRoot: string): readonly string[] {
-  const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
-  const found: string[] = [];
-  for (const path of workflowFiles(host, dir)) {
-    let text: string;
-    try {
-      text = host.readFile(path);
-    } catch {
+/**
+ * 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: Host, root: string): readonly { token: string; dir: string }[] {
+  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: { token: string; dir: string }[] = [];
+  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: string): string {
+  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;
+}
+
 /**
- * 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.
+ * 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: Host, targetRoot: string): readonly string[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  const commands: string[] = [];
+  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 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: Host,
@@ -107,5 +201,16 @@ export function workflowEntries(
       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/src/workspace-programs.ts

@@ -16,6 +16,7 @@ import type {
 } from "@typescript/native/sync";
 import { isStringLiteralLikeNode } from "@typescript/native/ast";
 import type { StringLiteralLikeNode } from "@typescript/native/ast";
+import { baseUrlPaths } from "./base-url.ts";
 import type { Host } from "./host.ts";
 import { dirnamePath, resolvePath } from "./paths.ts";
 import type { Engine } from "./session.ts";
@@ -62,7 +63,8 @@ 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.
  */
@@ -75,7 +77,9 @@ function analysisOptions(parsed: Parsed): CreateSnapshotProgramParams["compilerO
     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. */
@@ -152,7 +156,7 @@ function configurationOf(
   const raw: unknown = (options as Record<string, unknown>)["pathsBasePath"];
   const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
   const paths: Record<string, string[]> = {};
-  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/src/workspace-resolution.ts

@@ -1,13 +1,13 @@
 /**
- * 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.ts";
+import { gitIgnored } from "./git-ignore.ts";
 import type { Host } from "./host.ts";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import { satisfies } from "./version-range.ts";
@@ -232,6 +232,32 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     return found;
   };
 
+  const root = workspace.members[0]?.dir;
+  const ignored = root === undefined ? () => false : gitIgnored(host, root);
+  const manifests = new Map<
+    string,
+    { dir: string; manifest: Record<string, unknown> } | undefined
+  >();
+  /** The nearest manifest at or above one directory, up to the workspace's root. */
+  const nearestManifest = (
+    dir: string,
+  ): { dir: string; manifest: Record<string, unknown> } | undefined => {
+    if (manifests.has(dir)) {
+      return manifests.get(dir);
+    }
+    let found: { dir: string; manifest: Record<string, unknown> } | undefined;
+    try {
+      const value: unknown = 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: readonly WorkspaceMember[], fromDir: string): Linked => {
     const name = candidates[0]?.name ?? "";
     const linked = linkedFrom(name, fromDir);
@@ -243,14 +269,16 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     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)),
+      declared.some((specifier) => dependsOn(specifier, member, owner?.dir ?? fromDir)),
     );
     const [one, two] = matched;
     if (one === undefined) {
@@ -265,6 +293,25 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
   const compiled = (member: WorkspaceMember, path: string): boolean =>
     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: WorkspaceMember, path: string): string | undefined => {
+    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
@@ -286,6 +333,9 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     if (found !== undefined) {
       return found;
     }
+    if (ignored(path)) {
+      return mirrored(member, path);
+    }
     return compiled(member, path) && host.kindOf(path) === "file" ? path : undefined;
   };
 
@@ -352,10 +402,12 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
       }
       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" };
       }