@cplieger/deadset-ts 8.0.0-dev.6 → 8.0.0-dev.8

package/src/verbs/analyze.ts

@@ -12,7 +12,7 @@ import {
   type RunAnalysis,
   type RunProject,
 } from "../analysis.ts";
-import { ConfigError, kindOf } from "../config.ts";
+import { kindOf } from "../config.ts";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.ts";
 import { moduleIdentity } from "../consumers.ts";
 import { analyzerProvenance, verdictOf } from "../findings-pass.ts";
@@ -23,7 +23,6 @@ import type { NotBuilt } from "../discover.ts";
 import { partialNotes } from "../partial.ts";
 import {
   buildReport,
-  LANGUAGE,
   capFindings,
   sortFindings,
   type ReportConfiguration,
@@ -39,6 +38,9 @@ import { resolve } from "../resolve.ts";
 import { otherSchemeRows, rowReason, writeBaseline, type Recorded } from "../suppress-file.ts";
 import type { UnseenLoad } from "../unseen-loads.ts";
 import { type Verb, type VerbOptions } from "./verb.ts";
+import { UsageError } from "../usage.ts";
+import { bytewise } from "../text/compare.ts";
+import { diagnose, message } from "../product.ts";
 
 /** The options `analyze` takes beside the ones every verb takes. */
 export const ANALYZE_OPTIONS: VerbOptions = {
@@ -60,7 +62,7 @@ class ReportPathError extends Error {
 
 /** The formats this analyzer renders, for a message that names them. */
 function formatNames(): string {
-  return [...RENDERINGS.keys()].sort().join(", ");
+  return [...RENDERINGS.keys()].sort(bytewise).join(", ");
 }
 
 /** The renderings one invocation writes: the ones it named, else the configuration's. */
@@ -69,14 +71,12 @@ function formatsOf(named: readonly string[], configured: readonly Format[]): rea
   const seen = new Set<string>();
   for (const format of formats) {
     if (!RENDERINGS.has(format as Format)) {
-      throw new ConfigError(
-        "malformed",
-        "",
+      throw new UsageError(
         `${JSON.stringify(format)} is not a format this analyzer renders: the formats are ${formatNames()}`,
       );
     }
     if (seen.has(format)) {
-      throw new ConfigError("malformed", "", `the format ${JSON.stringify(format)} is named twice`);
+      throw new UsageError(`the format ${JSON.stringify(format)} is named twice`);
     }
     seen.add(format);
   }
@@ -188,9 +188,7 @@ function templateOf(
 ): Template | undefined {
   if (named === undefined || named === "") {
     if (formats.includes("template")) {
-      throw new ConfigError(
-        "malformed",
-        "",
+      throw new UsageError(
         "the template format renders the template --template names, and none was named",
       );
     }
@@ -200,11 +198,7 @@ function templateOf(
   try {
     source = host.readFile(resolvePath(invoked, named));
   } catch (error: unknown) {
-    throw new ConfigError(
-      "malformed",
-      "",
-      `--template=${named}: ${error instanceof Error ? error.message : String(error)}`,
-    );
+    throw new UsageError(`--template=${named}: ${message(error)}`);
   }
   try {
     return parseTemplate(source);
@@ -212,7 +206,7 @@ function templateOf(
     if (!(error instanceof TemplateError)) {
       throw error;
     }
-    throw new ConfigError("malformed", "", `--template=${named}: ${error.message}`);
+    throw new UsageError(`--template=${named}: ${error.message}`);
   }
 }
 
@@ -234,25 +228,17 @@ interface Documents {
 export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option, repeated }) => {
   const reportPath = option("report");
   if (reportPath === undefined || reportPath === "") {
-    throw new ConfigError(
-      "malformed",
-      "",
+    throw new UsageError(
       "analyze writes its report to the path --report names, and no path was named",
     );
   }
   const exitCode = option("exit-code") ?? EXIT_CODE_ON;
   if (exitCode !== EXIT_CODE_ON && exitCode !== EXIT_CODE_OFF) {
-    throw new ConfigError(
-      "malformed",
-      "",
+    throw new UsageError(
       `--exit-code=${JSON.stringify(exitCode)}: the values are ${EXIT_CODE_ON} and ${EXIT_CODE_OFF}`,
     );
   }
   const { config, provenance } = resolve(inputs());
-  const kind = config.targetKind;
-  if (kind === "") {
-    throw new ConfigError("missing-target-kind", "target.kind", "target.kind is not set");
-  }
   const invoked = host.workingDirectory();
   const baseline = option("baseline-write");
   const documents: Documents = {
@@ -268,7 +254,7 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
   try {
     version = host.analyzerVersion();
   } catch (error: unknown) {
-    err.write(`deadset-ts: ${error instanceof Error ? error.message : String(error)}\n`);
+    diagnose(err, message(error));
     return EXIT_FAILURE;
   }
 
@@ -321,7 +307,7 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       conformance: CONFORMANCE,
       declaredGaps: DECLARED_GAPS,
       target: {
-        kind: kindOf(kind, LANGUAGE),
+        kind: kindOf(config.target.kind),
         root,
         identity: moduleIdentity(host, scoped.target),
       },
@@ -343,13 +329,13 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
         ...unseenLoadNotes(run.unseenLoads),
       ],
     });
-    report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
+    report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.max_findings);
     verdict = verdictOf(result, config);
   } catch (error: unknown) {
     if (!(error instanceof ReportPathError)) {
       throw error;
     }
-    err.write(`deadset-ts: ${error.message}\n`);
+    diagnose(err, error.message);
     return EXIT_FAILURE;
   }
 
@@ -382,38 +368,42 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       );
     }
   } catch (error: unknown) {
-    err.write(`deadset-ts: ${error instanceof Error ? error.message : String(error)}\n`);
+    diagnose(err, message(error));
     return EXIT_FAILURE;
   }
 
   for (const note of partial) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   for (const line of [...unread, ...unfound]) {
-    err.write(`deadset-ts: ${line}\n`);
+    diagnose(err, line);
   }
   for (const warning of warnings) {
-    err.write(
-      `deadset-ts: ${warning.path}:${String(warning.line)}: a <script> start tag that begins a line is not read as a block: ${warning.reason}\n`,
+    diagnose(
+      err,
+      `${warning.path}:${String(warning.line)}: a <script> start tag that begins a line is not read as a block: ${warning.reason}`,
     );
   }
   for (const skip of report.type_error_skips) {
-    err.write(
-      `deadset-ts: ${skip.path}:${String(skip.line)}: ${skip.message}: the function or statement holding this type error is not evaluated\n`,
+    diagnose(
+      err,
+      `${skip.path}:${String(skip.line)}: ${skip.message}: the function or statement holding this type error is not evaluated`,
     );
   }
   if (report.totals.pending > 0) {
-    err.write(
-      `deadset-ts: ${counted(report.totals.pending, "pending finding")}: the report names a declared cross-language edge, and no merge has resolved it\n`,
+    diagnose(
+      err,
+      `${counted(report.totals.pending, "pending finding")}: the report names a declared cross-language edge, and no merge has resolved it`,
     );
   }
   if (report.totals.stale_suppressions > 0) {
-    err.write(`deadset-ts: ${counted(report.totals.stale_suppressions, "stale suppression")}\n`);
+    diagnose(err, counted(report.totals.stale_suppressions, "stale suppression"));
   }
   if (exitCode === EXIT_CODE_OFF) {
     if (verdict !== EXIT_CLEAN) {
-      err.write(
-        `deadset-ts: the exit code is configured off: the verdict of this run is ${String(verdict)}\n`,
+      diagnose(
+        err,
+        `the exit code is configured off: the verdict of this run is ${String(verdict)}`,
       );
     }
     return EXIT_CLEAN;

package/src/verbs/describe.ts

@@ -6,8 +6,8 @@ import {
   SCHEMA_VERSIONS,
 } from "../contract/contract.generated.ts";
 import { CONFORMANCE, type Conformance } from "../conformance.ts";
-import { ANALYZER_NAME, LANGUAGE } from "../report.ts";
 import { type Verb } from "./verb.ts";
+import { diagnose, LANGUAGE, message, PRODUCT } from "../product.ts";
 
 /**
  * The document `describe` writes: the analyzer, the Contract version it implements, the
@@ -16,7 +16,7 @@ import { type Verb } from "./verb.ts";
  */
 export function describeDocument(version: string, recorded: Conformance | undefined): string {
   const document = {
-    name: ANALYZER_NAME,
+    name: PRODUCT,
     version,
     contract_version: CONTRACT_VERSION,
     schema_versions_accepted: SCHEMA_VERSIONS,
@@ -37,14 +37,14 @@ export function describeDocument(version: string, recorded: Conformance | undefi
 /** Writes this analyzer's description to the output stream, and nothing to the error stream. */
 export const describeVerb: Verb = ({ out, err, host, args }) => {
   if (args.length > 0) {
-    err.write(`deadset-ts: describe takes no argument, got ${JSON.stringify(args[0])}\n`);
+    diagnose(err, `describe takes no argument, got ${JSON.stringify(args[0])}`);
     return EXIT_USAGE;
   }
   let version: string;
   try {
     version = host.analyzerVersion();
   } catch (error: unknown) {
-    err.write(`deadset-ts: describe: ${error instanceof Error ? error.message : String(error)}\n`);
+    diagnose(err, `describe: ${message(error)}`);
     return EXIT_FAILURE;
   }
   out.write(describeDocument(version, CONFORMANCE));

package/src/verbs/explain.ts

@@ -2,7 +2,6 @@ import { EXIT_CLEAN, EXIT_USAGE } from "../contract/contract.generated.ts";
 import { runAnalysis, type RunAnalysis } from "../analysis.ts";
 import { listing } from "../components.ts";
 import type { Cascade } from "../config.ts";
-import { ConfigError } from "../config.ts";
 import type { CompletedFinding } from "../finding.ts";
 import { OUTSIDE, swept as judged } from "../graph.ts";
 import type { InventorySymbol } from "../inventory.ts";
@@ -14,6 +13,9 @@ import type { Reference } from "../references.ts";
 import { resolve } from "../resolve.ts";
 import type { Root } from "../roots.ts";
 import { type Verb, type VerbOptions } from "./verb.ts";
+import { UsageError } from "../usage.ts";
+import { bytewise } from "../text/compare.ts";
+import { diagnose } from "../product.ts";
 
 /**
  * The three spellings of an explanation request, each naming the symbol to explain. They are
@@ -45,16 +47,12 @@ function namedSymbol(option: (name: string) => string | undefined): string {
   });
   const [only, ...more] = named;
   if (only === undefined) {
-    throw new ConfigError(
-      "malformed",
-      "",
+    throw new UsageError(
       "explain explains the symbol --why, --why-live or --why-not names, and none was named",
     );
   }
   if (more.length > 0) {
-    throw new ConfigError(
-      "malformed",
-      "",
+    throw new UsageError(
       `explain explains one symbol, and ${named.map((one) => `--${one.name}`).join(", ")} each name one`,
     );
   }
@@ -102,7 +100,7 @@ function subjectOf(
         symbol.ref.toLowerCase().includes(folded) || symbol.name.toLowerCase().includes(folded),
     )
     .map(described)
-    .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    .sort(bytewise);
   return { candidates: partial.slice(0, MAX_PARTIAL_MATCHES) };
 }
 
@@ -381,7 +379,7 @@ export const explainVerb: Verb = ({ out, err, host, inputs, scope, openClient, o
     targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
   });
   if (subject === undefined) {
-    err.write(`deadset-ts: ${JSON.stringify(named)} names no one symbol of the target\n`);
+    diagnose(err, `${JSON.stringify(named)} names no one symbol of the target`);
     for (const candidate of candidates) {
       err.write(`  ${candidate}\n`);
     }
@@ -392,7 +390,7 @@ export const explainVerb: Verb = ({ out, err, host, inputs, scope, openClient, o
     out.write(explanation(analysis, subject, config.reporters.cascade));
   }
   for (const note of notes) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   return subject === undefined ? EXIT_USAGE : EXIT_CLEAN;
 };

package/src/verbs/print-projects.ts

@@ -2,8 +2,9 @@ import { EXIT_CLEAN } from "../contract/contract.generated.ts";
 import { runProjects } from "../analysis.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
-import { resolveUnkinded } from "../resolve.ts";
+import { resolvePartial } from "../resolve.ts";
 import { type Verb } from "./verb.ts";
+import { diagnose } from "../product.ts";
 
 /**
  * Writes the name of every project one run analyzes, one per line: the identifier the
@@ -13,7 +14,7 @@ import { type Verb } from "./verb.ts";
  * instead, and one that fails the analysis fails this command the same way.
  */
 export const printProjectsVerb: Verb = ({ out, err, host, inputs, scope, openClient }) => {
-  const config = resolveUnkinded(inputs());
+  const config = resolvePartial(inputs());
   const scoped = scope();
   const answer = runProjects(openClient(config), host, scoped, config);
   for (const id of answer.configurations) {
@@ -24,7 +25,7 @@ export const printProjectsVerb: Verb = ({ out, err, host, inputs, scope, openCli
     unanswered: answer.unanswered,
     targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
   })) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   return EXIT_CLEAN;
 };

package/src/verbs/print-retained.ts

@@ -5,6 +5,7 @@ import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.ts";
 import { type Verb } from "./verb.ts";
+import { diagnose } from "../product.ts";
 
 /**
  * Writes every declaration an exemption held back in the production sweep a report is
@@ -28,7 +29,7 @@ export const printRetainedVerb: Verb = ({ out, err, host, inputs, scope, openCli
     unanswered: swept.unanswered,
     targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
   })) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   return EXIT_CLEAN;
 };

package/src/verbs/print-roots.ts

@@ -4,6 +4,7 @@ import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.ts";
 import { type Verb } from "./verb.ts";
+import { diagnose } from "../product.ts";
 
 /**
  * One root as a line: the declaration's reference, why it is a root, and the string
@@ -42,7 +43,7 @@ export const printRootsVerb: Verb = ({ out, err, host, inputs, scope, openClient
     unanswered: answer.unanswered,
     targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
   })) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;
 };

package/src/verbs/verb.ts

@@ -1,4 +1,4 @@
-import type { Config, Inputs } from "../config.ts";
+import type { Inputs, PartialConfig } from "../config.ts";
 import type { Host } from "../host.ts";
 import type { Writer } from "../run.ts";
 import type { Scope } from "../scope.ts";
@@ -21,7 +21,7 @@ interface Invocation {
    * Opens the compiler client for a run under `config`. A client the verb opened is
    * closed if the verb throws.
    */
-  readonly openClient: (config: Config) => Engine;
+  readonly openClient: (config: PartialConfig) => Engine;
   /** The arguments after the verb's name, as written. */
   readonly args: readonly string[];
   /** The last value one of the verb's own options was given, undefined where none was. */

package/src/verbs/version.ts

@@ -1,8 +1,9 @@
 import { CONTRACT_VERSION, EXIT_CLEAN } from "../contract/contract.generated.ts";
 import { type Verb } from "./verb.ts";
+import { PRODUCT } from "../product.ts";
 
 /** Writes the version the host reports and the Contract version this analyzer implements. */
 export const versionVerb: Verb = ({ out, host }) => {
-  out.write(`deadset-ts ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
+  out.write(`${PRODUCT} ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
   return EXIT_CLEAN;
 };

package/src/workflow-steps.ts

@@ -6,9 +6,10 @@
 
 import type { SourceFile } from "@typescript/native/ast";
 import type { Host } from "./host.ts";
-import { scriptTokens } from "./manifest.ts";
 import { joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { SourceFiles } from "./source-files.ts";
+import { filesIn } from "./fs/tree.ts";
+import { commandsOf, scriptTokens, unquoted, withoutComment } from "./text/shell.ts";
 
 /** One file a workflow step names. */
 interface WorkflowEntry {
@@ -36,30 +37,16 @@ const HOOK_MANAGERS: readonly (readonly [string, RegExp])[] = [
 /** 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;
-
 /** A token holding one of these is computed or a pattern, so it names no file. */
 const COMPUTED = /[${*?[]/u;
 
 const INDENT = /^\s*/u;
 
-/** 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);
-  } catch {
-    return [];
-  }
-  return entries
-    .filter((entry) => !entry.directory && accepts(entry.name))
-    .map((entry) => joinPath(dir, entry.name))
-    .sort();
+/** The files directly in one directory whose name `accepts`, by path in name order. */
+function pathsIn(host: Host, dir: string, accepts: (name: string) => boolean): readonly string[] {
+  return filesIn(host, dir, accepts).map((name) => joinPath(dir, name));
 }
 
 function readText(host: Host, path: string): string | undefined {
@@ -80,7 +67,7 @@ export function runCommands(text: string, key: RegExp = RUN_LINE): readonly stri
       continue;
     }
     const column = (match[1] ?? "").length;
-    const value = (match[2] ?? "").trim().replace(QUOTED, "$2");
+    const value = unquoted((match[2] ?? "").trim());
     if (!BLOCK_SCALAR.test(value)) {
       found.push(value);
       continue;
@@ -113,7 +100,7 @@ function recipeLines(host: Host, root: string): readonly (readonly string[])[] {
     .replace(/\\\r?\n/gu, " ")
     .split(/\r?\n/u)
     .filter((line) => line.startsWith("\t"))
-    .map((line) => withoutComment(line.slice(1).replace(/^[@+-]+/u, "")).split(COMMAND_SEPARATORS));
+    .map((line) => commandsOf(withoutComment(line.slice(1).replace(/^[@+-]+/u, ""))));
 }
 
 /**
@@ -140,28 +127,6 @@ function recipeTokens(host: Host, root: string): readonly { token: string; 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;
-}
-
 /**
  * Every command the target root's workflow steps, git hooks and makefile run: the `run:`
  * steps of the workflow files in `.github/workflows`, every line of each file in `.husky`
@@ -185,11 +150,11 @@ export function workflowTokens(host: Host, targetRoot: string): readonly string[
 /** The commands of the workflow steps, git hooks and hook managers at one root. */
 function stepCommands(host: Host, root: string): readonly string[] {
   const commands: string[] = [];
-  for (const path of filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name))) {
+  for (const path of pathsIn(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)) {
+    for (const path of pathsIn(host, joinPath(root, dir), () => true)) {
       commands.push(...(readText(host, path) ?? "").split(/\r?\n/u).map(withoutComment));
     }
   }

package/src/workspace-manifests.ts

@@ -12,6 +12,7 @@ import { readManifest, type Manifest, type ManifestEntry } from "./manifest.ts";
 import { joinPath, relativePath } from "./paths.ts";
 import type { WorkspaceMember } from "./workspace.ts";
 import type { WorkspaceResolver } from "./workspace-resolution.ts";
+import { MANIFEST } from "./fs/manifest.ts";
 
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
@@ -84,8 +85,7 @@ export function memberEntries(
     }
     const manifest = readManifest(host, member.dir);
     const where =
-      relativePath(targetRoot, joinPath(member.dir, "package.json")) ??
-      joinPath(member.dir, "package.json");
+      relativePath(targetRoot, joinPath(member.dir, MANIFEST)) ?? joinPath(member.dir, MANIFEST);
     const kept = manifest.entries.flatMap((entry): ManifestEntry[] => {
       const exported = entry.member.startsWith("exports");
       if (member.private && exported) {

package/src/workspace-programs.ts

@@ -21,6 +21,8 @@ import type { Host } from "./host.ts";
 import { dirnamePath, resolvePath } from "./paths.ts";
 import type { Engine } from "./session.ts";
 import type { WorkspaceResolver } from "./workspace-resolution.ts";
+import { bytewise } from "./text/compare.ts";
+import { PRODUCT } from "./product.ts";
 
 /** One member import no member source answers for. */
 interface UnresolvedImport {
@@ -129,7 +131,7 @@ function unstatable(reading: Reading): string | undefined {
 export function writtenPath(host: Host, configFile: string): string {
   const stem = configFile.replace(/\.json$/u, "");
   for (let counter = 0; ; counter += 1) {
-    const path = `${stem}.deadset-ts${counter === 0 ? "" : `-${String(counter)}`}.json`;
+    const path = `${stem}.${PRODUCT}${counter === 0 ? "" : `-${String(counter)}`}.json`;
     if (host.kindOf(path) === "absent") {
       return path;
     }
@@ -181,10 +183,10 @@ function configurationOf(
     ...(exclude === undefined ? {} : { exclude }),
   });
   const file = writtenPath(host, reading.configFile);
-  const expected = [...reading.parsed.fileNames].sort().join("\u0000");
+  const expected = [...reading.parsed.fileNames].sort(bytewise).join("\u0000");
   const listed = (value: Record<string, unknown>): string | undefined => {
     try {
-      return [...engine.parseConfigJson(value, file).fileNames].sort().join("\u0000");
+      return [...engine.parseConfigJson(value, file).fileNames].sort(bytewise).join("\u0000");
     } catch {
       return undefined;
     }

package/src/workspace-resolution.ts

@@ -9,9 +9,18 @@
 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 {
+  ancestors,
+  dirnamePath,
+  isAbsolutePath,
+  joinPath,
+  relativePath,
+  resolvePath,
+} from "./paths.ts";
 import { satisfies } from "./version-range.ts";
 import type { Workspace, WorkspaceMember } from "./workspace.ts";
+import { isRecord } from "./json-document.ts";
+import { INSTALLED_PACKAGES, MANIFEST, manifestAt } from "./fs/manifest.ts";
 
 /** What the compiler's own resolution answered for one import. */
 export interface DefaultResolution {
@@ -47,10 +56,6 @@ const DEPENDENCY_MEMBERS = [
 const SOURCE = /(?<!\.d)\.(?:[mc]?ts|tsx)$/u;
 const OUTPUT = /(?:\.d\.[mc]?ts|\.[mc]?js|\.jsx)$/u;
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 /** The package name a bare specifier names, or `undefined` for any other specifier. */
 export function packageNameOf(specifier: string): string | undefined {
   if (
@@ -216,7 +221,7 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     if (links.has(key)) {
       return links.get(key);
     }
-    const candidate = joinPath(dir, "node_modules", name);
+    const candidate = joinPath(dir, INSTALLED_PACKAGES, name);
     let found: string | undefined;
     if (host.kindOf(candidate) === "absent") {
       const up = dirnamePath(dir);
@@ -245,15 +250,14 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     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);
-    }
+    const manifest = manifestAt(host, dir);
+    const up = dirnamePath(dir);
+    const found =
+      manifest !== undefined
+        ? { dir, manifest }
+        : up === dir || root === undefined || !inside(root, up)
+          ? undefined
+          : nearestManifest(up);
     manifests.set(dir, found);
     return found;
   };
@@ -265,7 +269,7 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
       const member = candidates.find((one) => one.dir === linked);
       return member === undefined ? { kind: "none" } : { kind: "member", member };
     }
-    const scope = workspace.memberOf(joinPath(fromDir, "package.json"));
+    const scope = workspace.memberOf(joinPath(fromDir, MANIFEST));
     if (scope?.name === name) {
       return { kind: "member", member: scope };
     }
@@ -300,7 +304,7 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
    * 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)) {
+    for (const dir of ancestors(dirnamePath(path), member.dir).filter((at) => at !== member.dir)) {
       const found = emittedFrom(path, { outDir: dir, sourceDirs: [member.dir] }).find(
         (candidate) =>
           SOURCE.test(candidate) && !ignored(candidate) && host.kindOf(candidate) === "file",