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

package/src/config.ts

@@ -1,4 +1,6 @@
-import { CONTRACT_VERSION } from "./version.ts";
+import type { ResolvedConfig } from "./contract/config.generated.ts";
+import { SEVERITIES, type Severity } from "./contract/contract.generated.ts";
+import { LANGUAGE } from "./product.ts";
 
 /**
  * The name of the repository configuration at the target root, which is also the
@@ -7,266 +9,32 @@ import { CONTRACT_VERSION } from "./version.ts";
  */
 export const REPOSITORY_DOCUMENT = "deadset.json";
 
-/**
- * Whether the target is an application, whose every caller is in the analyzed
- * graph, or a library, whose published API has callers outside it.
- */
-export type TargetKind = "application" | "library";
+export type { PartialConfig, ResolvedConfig } from "./contract/config.generated.ts";
 
-/** The target kind as a source writes it: one kind for every language, or one per language. */
-export type TargetKindSetting = TargetKind | { readonly go: TargetKind; readonly ts: TargetKind };
+/** Whether the target is an application or a library. */
+export type TargetKind = Extract<ResolvedConfig["target"]["kind"], string>;
+export type DeclarationEntry = ResolvedConfig["ts"]["serializers"][number];
+export type LifecycleContract = ResolvedConfig["ts"]["lifecycle_contracts"][number];
+export type BuildConfiguration = ResolvedConfig["analysis"]["configurations"][number];
+export type ProjectConfiguration = Extract<BuildConfiguration, { readonly project: string }>;
+export type TemplateDelimiters = ResolvedConfig["analysis"]["template_delimiters"];
+export type Sort = ResolvedConfig["reporters"]["sort"];
+export type Cascade = ResolvedConfig["reporters"]["cascade"];
 
-/** The kind a target kind setting gives one language's declarations. */
-export function kindOf(setting: TargetKindSetting, language: Language): TargetKind {
-  return typeof setting === "string" ? setting : setting[language];
+/** The kind a target kind setting gives this analyzer's declarations. */
+export function kindOf(kind: ResolvedConfig["target"]["kind"]): TargetKind {
+  return typeof kind === "string" ? kind : kind[LANGUAGE];
 }
 
-/** The lowest reachability class a finding must reach to be reported. */
-export type Confidence = "certain" | "probable" | "possible";
-
-/** Whether declarations in generated files are analyzed. */
-export type GeneratedFiles = "exclude" | "include";
-
-/** How a reference from a consumer's test file counts. */
-export type ConsumerTests = "test" | "production";
-
-/** One language an analysis covers. */
-export type Language = "go" | "ts";
-
-/** What a finding of one issue kind does to a run. */
-export type Severity = "allow" | "warn" | "deny";
-
-/** The severities ranked, the strongest highest. */
-const SEVERITY_RANK: Readonly<Record<Severity, number>> = { allow: 0, warn: 1, deny: 2 };
-
 /** Whether a finding at one severity fails a run under the failing severity. */
 export function fails(severity: Severity, failOn: Severity): boolean {
-  return SEVERITY_RANK[severity] >= SEVERITY_RANK[failOn];
-}
-
-/** One rendering of the finding list. */
-export type Format = "text" | "json" | "github" | "sarif" | "template";
-
-/** The order findings are rendered in. */
-export type Sort = "position" | "size";
-
-/** How much of a dead component a rendering names. */
-export type Cascade = "roots" | "full";
-
-/**
- * A platform configuration: an operating system, an architecture and the build
- * tags in effect. It is the shape a language built under build constraints reads,
- * and this analyzer leaves it to that analysis.
- */
-interface PlatformConfiguration {
-  readonly shape: "platform";
-  readonly id: string;
-  readonly os: string;
-  readonly arch: string;
-  readonly tags: readonly string[];
-}
-
-/**
- * A project configuration: one compiler configuration file, as a path below the
- * target root with `/` between segments.
- */
-export interface ProjectConfiguration {
-  readonly shape: "project";
-  readonly id: string;
-  readonly project: string;
-}
-
-/**
- * One entry of the build matrix: a configuration the target builds under, in
- * exactly one of the two shapes the matrix admits.
- */
-export type BuildConfiguration = PlatformConfiguration | ProjectConfiguration;
-
-/**
- * The pair of action delimiters a template is parsed with. Both members are
- * required once a document names the object, so the pair is one setting rather
- * than two.
- */
-export interface TemplateDelimiters {
-  readonly left: string;
-  readonly right: string;
-}
-
-/** How the analysis is scoped and filtered. */
-export interface Analysis {
-  readonly languages: readonly Language[];
-  readonly minConfidence: Confidence;
-  readonly generatedFiles: GeneratedFiles;
-  readonly consumerTests: ConsumerTests;
-  readonly configurations: readonly BuildConfiguration[];
-  readonly matrixComplete: boolean;
-  readonly templateDirs: readonly string[];
-  readonly templateDelimiters: TemplateDelimiters;
-}
-
-/** How findings are rendered. */
-interface Reporters {
-  readonly formats: readonly Format[];
-  readonly sort: Sort;
-  readonly cascade: Cascade;
-  readonly maxFindings: number;
-  readonly failOn: Severity;
-}
-
-/**
- * One declaration a configuration entry names, in exactly one of three shapes: a
- * declaration of the analyzed program by its stable symbol reference, a declaration a
- * module exports by the bare specifier an import writes for the module and the
- * declaration's path from its exports, or a declaration of the global scope by its
- * path from that scope. A path joins the name and each member with dots and spells a
- * static member with `:static` after it.
- */
-export type DeclarationEntry =
-  | { readonly shape: "symbol"; readonly symbol: string }
-  | { readonly shape: "module"; readonly module: string; readonly name: string }
-  | { readonly shape: "global"; readonly global: string };
-
-/**
- * One framework's lifecycle contract: the declarations whose use makes a class one of
- * the framework's components, the classes whose subclasses are its components, and the
- * names of the members the framework calls on a component, each spelled as the last
- * component of a member's stable symbol reference.
- */
-export interface LifecycleContract {
-  readonly components: readonly DeclarationEntry[];
-  readonly bases: readonly DeclarationEntry[];
-  readonly members: readonly string[];
-}
-
-/**
- * One analyzer the orchestrator may run, in exactly one of two shapes: an installed
- * analyzer, named by its command alone, or an acquirable one, which also names the
- * artifact acquisition fetches and verifies. This analyzer validates and prints the
- * list and runs nothing from it.
- */
-export type Provider =
-  | {
-      readonly shape: "installed";
-      readonly name: string;
-      readonly languages: readonly Language[];
-      readonly command: string;
-    }
-  | {
-      readonly shape: "acquirable";
-      readonly name: string;
-      readonly languages: readonly Language[];
-      readonly command: string;
-      readonly source: string;
-      readonly version: string;
-      readonly digest: string;
-    };
-
-/** The analyzers the orchestrator runs. */
-interface Providers {
-  readonly analyzers: readonly Provider[];
-}
-
-/** The section the TypeScript analyzer owns. */
-export interface TSSection {
-  readonly testFiles: readonly string[];
-  readonly entryFiles: readonly string[];
-  readonly componentExtensions: readonly string[];
-  readonly disabledConventions: readonly string[];
-  readonly injectionRegistrations: readonly DeclarationEntry[];
-  readonly lifecycleContracts: readonly LifecycleContract[];
-  readonly serializers: readonly DeclarationEntry[];
-  /** Whether the maintainer declares the roots the analysis finds every root the target has. */
-  readonly rootsComplete: boolean;
-}
-
-/**
- * The resolved configuration: the closed key list of the Contract's
- * configuration schema, decoded, with every default applied.
- *
- * `targetKind` is empty exactly in the configuration every default states, which
- * is not a configuration a run may use: the field has no default and resolution
- * refuses a result that carries none.
- *
- * `severity` is a map rather than an object because its keys come from a
- * document, and an object keyed by document text answers for names it never
- * held. The order it is written in is the emitter's, not the map's.
- */
-export interface Config {
-  readonly contractVersion: string;
-  readonly targetKind: TargetKindSetting | "";
-  readonly analysis: Analysis;
-  readonly consumersComplete: boolean;
-  readonly rootPatterns: readonly string[];
-  readonly severity: ReadonlyMap<string, Severity>;
-  readonly exemptionsDisabled: readonly string[];
-  readonly reporters: Reporters;
-  readonly providers: Providers;
-  readonly ts: TSSection;
-}
-
-/**
- * The configuration every documented default states. `targetKind` is empty: the
- * field has no default and is never inferred.
- */
-export function defaultConfig(): Config {
-  return {
-    contractVersion: CONTRACT_VERSION,
-    targetKind: "",
-    analysis: {
-      languages: [],
-      minConfidence: "probable",
-      generatedFiles: "exclude",
-      consumerTests: "test",
-      configurations: [],
-      matrixComplete: false,
-      templateDirs: [],
-      templateDelimiters: { left: "{{", right: "}}" },
-    },
-    consumersComplete: false,
-    rootPatterns: [],
-    severity: new Map(),
-    exemptionsDisabled: [],
-    reporters: {
-      formats: ["text"],
-      sort: "position",
-      cascade: "roots",
-      maxFindings: 0,
-      failOn: "deny",
-    },
-    providers: {
-      analyzers: [
-        { shape: "installed", name: "deadset-go", languages: ["go"], command: "deadset-go" },
-        { shape: "installed", name: "deadset-ts", languages: ["ts"], command: "deadset-ts" },
-      ],
-    },
-    ts: {
-      testFiles: [
-        "**/*.test.{ts,tsx,mts,cts}",
-        "**/*.test-d.{ts,tsx,mts,cts}",
-        "**/*.spec-d.{ts,tsx,mts,cts}",
-        "**/*.spec.*",
-        "**/__tests__/**",
-        "**/__mocks__/**",
-        "**/test-d/**",
-      ],
-      entryFiles: [],
-      componentExtensions: [".vue", ".svelte", ".astro"],
-      disabledConventions: [],
-      injectionRegistrations: [],
-      lifecycleContracts: [],
-      serializers: [],
-      rootsComplete: false,
-    },
-  };
+  return SEVERITIES.indexOf(severity) >= SEVERITIES.indexOf(failOn);
 }
 
 /** Where a resolved setting came from, in the order the sources outrank each other. */
 export type Source = "flag" | "repository" | "central" | "default";
 
-/**
- * One setting's source together with the file or flag that supplied it. `label`
- * is empty exactly when `source` is `"default"`.
- */
+/** One setting's source with the file or flag that supplied it, empty for a default. */
 export interface Origin {
   readonly source: Source;
   readonly label: string;
@@ -281,63 +49,24 @@ export function renderOrigin(origin: Origin): string {
 }
 
 /**
- * The origin of each resolved setting, keyed by the setting's dotted path. A
- * section holds no value of its own and has no entry; the severity object
- * carries one entry per code it names, or the entry `severity` alone when it is
- * empty.
+ * The origin of each resolved setting, keyed by the setting's dotted path. A section
+ * has no entry; a keyed section carries one entry per member it names, or one for
+ * itself when it is empty.
  */
 export type Provenance = ReadonlyMap<string, Origin>;
 
-/**
- * The configuration documents one invocation reads, each the document's text or
- * absent. `repositoryLabel` names the document `repository` holds and
- * `centralLabel` the one `central` holds; `flagLabels` names the flag that
- * supplied each setting `flags` names, keyed by dotted setting path.
- */
-export interface Inputs {
-  readonly flags?: string;
-  readonly repository?: string;
-  readonly central?: string;
-  readonly repositoryLabel?: string;
-  readonly centralLabel?: string;
-  readonly flagLabels?: ReadonlyMap<string, string>;
+/** One configuration document: its text and the path it was read from. */
+export interface Document {
+  readonly text: string;
+  readonly label: string;
 }
 
-/** Which refusal a {@link ConfigError} carries. */
-type ErrorKind =
-  /**
-   * A document that is not one JSON instance of the closed key list: a syntax
-   * error, a value of the wrong type, a value outside the closed set a key
-   * declares, or a member written twice at one level.
-   */
-  | "malformed"
-  /**
-   * A key the closed key list does not declare, or a severity key naming no live
-   * kind or a kind whose severity the Contract fixes.
-   */
-  | "unimplemented-key"
-  /** A resolved configuration no source supplied a target kind for. */
-  | "missing-target-kind";
-
 /**
- * Every refusal configuration resolution makes. Each maps to the usage exit
- * code, and each is thrown rather than returned: a refusal ends the run, and the
- * one caller that turns it into an exit code is the command line.
+ * The configuration sources one invocation carries. `flags` holds the text each
+ * setting option was given, by the setting's dotted path.
  */
-export class ConfigError extends Error {
-  /** Which refusal this is. */
-  readonly kind: ErrorKind;
-
-  /**
-   * The key or field the message names, spelled as the document spells it. It is
-   * empty when the refusal names none.
-   */
-  readonly key: string;
-
-  constructor(kind: ErrorKind, key: string, message: string) {
-    super(message);
-    this.name = "ConfigError";
-    this.kind = kind;
-    this.key = key;
-  }
+export interface Inputs {
+  readonly flags?: ReadonlyMap<string, string>;
+  readonly repository?: Document;
+  readonly central?: Document;
 }

package/src/configuration-files.ts

@@ -19,10 +19,19 @@ import {
   type SourceFile,
 } from "@typescript/native/ast";
 import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { SourceFiles } from "./source-files.ts";
-
-const MANIFEST = "package.json";
+import { bytewise } from "./text/compare.ts";
+import { isRecord } from "./json-document.ts";
+import { filesIn } from "./fs/tree.ts";
+import {
+  DEPENDENCY_SECTIONS,
+  holdsManifest,
+  inInstalledPackages,
+  manifestAt,
+  readJSON,
+} from "./fs/manifest.ts";
+import { shellWords } from "./text/shell.ts";
 
 /** A configuration module's name, each form with the spelling a root reports it by. */
 const MODULE_FORMS: readonly { readonly name: RegExp; readonly form: string }[] = [
@@ -37,14 +46,6 @@ const MODULE_FORMS: readonly { readonly name: RegExp; readonly form: string }[]
 /** A JSON configuration file's name. */
 const DOCUMENT_NAME = /^(?:[\w-]+(?:\.[\w-]+)?\.config\.json|\.[\w-]+rc(?:\.json)?)$/u;
 
-/** The manifest members a dependency is declared in. */
-const DEPENDENCY_MEMBERS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-] as const;
-
 /** The prefixes a string names a file with, relative to the file that writes it. */
 const RELATIVE_PREFIXES = ["./", "../"] as const;
 
@@ -72,9 +73,6 @@ export const RESOLVED_EXTENSIONS = [
   ".cjs",
 ] as const;
 
-/** The directory a package manager installs packages into, whose files are no project's own. */
-const MODULES_DIR = "node_modules";
-
 /** The file's name, the last segment of its path. */
 function basename(path: string): string {
   return path.slice(path.lastIndexOf("/") + 1);
@@ -82,11 +80,8 @@ function basename(path: string): string {
 
 /** Whether one path is the project's own: below the target root and in no `node_modules`. */
 function isProjectPath(root: string, path: string): boolean {
-  return relativePath(root, path)?.split("/").includes(MODULES_DIR) === false;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  const below = relativePath(root, path);
+  return below !== undefined && !inInstalledPackages(below);
 }
 
 /** The form one file name is as a configuration module, or undefined where it is none. */
@@ -126,120 +121,13 @@ const CONFIG_FLAGS: ReadonlySet<string> = new Set(["--config", "-c"]);
 /** The extensions of a module a configuration flag may name. */
 const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"] as const;
 
-/** The characters that end a word outside quotes and separate nothing: blanks. */
-// Stryker disable next-line Regex: its \v to \V mutant is no valid escape under the u flag, so the whole module fails to parse
-const BLANK = /[ \t\r\f\v]/u;
-
-/** The characters that end a word outside quotes and begin an operator: newline included. */
-const OPERATOR = /[\n;&|()<>]/u;
-
-/** The characters a backslash escapes inside double quotes; before any other it stands for itself. */
-const DOUBLE_QUOTE_ESCAPES = new Set(["$", "`", '"', "\\"]);
-
-/**
- * The words of one command line, as POSIX token recognition reads quotes, backslashes,
- * line continuations, comments and operators. A word an expansion may change (an unquoted
- * `$`, backquote, glob character or leading `~`, or a `$` or backquote in double quotes)
- * is computed, and so is the rest of a line whose quote is never closed. A computed word
- * and each operator are undefined, so a flag's file is never read across them.
- */
-function shellWords(command: string): readonly (string | undefined)[] {
-  const words: (string | undefined)[] = [];
-  let word: string | undefined;
-  let computed = false;
-  const end = (): void => {
-    if (word !== undefined) {
-      words.push(computed ? undefined : word);
-    }
-    word = undefined;
-    computed = false;
-  };
-  for (let at = 0; at < command.length; at += 1) {
-    const char = command.charAt(at);
-    if (char === "\\" && command.charAt(at + 1) === "\n") {
-      at += 1;
-    } else if (BLANK.test(char)) {
-      end();
-    } else if (OPERATOR.test(char)) {
-      end();
-      words.push(undefined);
-    } else if (char === "#" && word === undefined) {
-      const newline = command.indexOf("\n", at);
-      at = newline < 0 ? command.length : newline - 1;
-    } else if (char === "\\") {
-      at += 1;
-      word = (word ?? "") + command.charAt(at);
-    } else if (char === "'" || char === '"') {
-      const close = closingQuote(command, at);
-      if (close < 0) {
-        word ??= "";
-        computed = true;
-        break;
-      }
-      const quoted =
-        char === "'"
-          ? { text: command.slice(at + 1, close), computed: false }
-          : doubleQuoted(command.slice(at + 1, close));
-      word = (word ?? "") + quoted.text;
-      computed ||= quoted.computed;
-      at = close;
-    } else {
-      computed ||= /[$`*?[]/u.test(char) || (char === "~" && word === undefined);
-      word = (word ?? "") + char;
-    }
-  }
-  end();
-  return words;
-}
-
-/** The text between one pair of double quotes, unescaped, and whether an expansion may change it. */
-function doubleQuoted(inner: string): { readonly text: string; readonly computed: boolean } {
-  let text = "";
-  let computed = false;
-  for (let at = 0; at < inner.length; at += 1) {
-    const char = inner.charAt(at);
-    const next = inner.charAt(at + 1);
-    if (char === "\\" && next === "\n") {
-      at += 1;
-    } else if (char === "\\" && DOUBLE_QUOTE_ESCAPES.has(next)) {
-      text += next;
-      at += 1;
-    } else {
-      computed ||= char === "$" || char === "`";
-      text += char;
-    }
-  }
-  return { text, computed };
-}
-
-/** The index of the quote that closes the one at `open`, or -1 where none does. */
-function closingQuote(command: string, open: number): number {
-  const quote = command.charAt(open);
-  for (let at = open + 1; at < command.length; at += 1) {
-    const char = command.charAt(at);
-    if (char === quote) {
-      return at;
-    }
-    if (quote === '"' && char === "\\") {
-      at += 1;
-    }
-  }
-  return -1;
-}
-
 /**
  * The files the scripts of the manifest in one directory name after a configuration flag,
  * `--config <file>`, `-c <file>` or `--config=<file>`, each a JSON file or a module below
  * the target root and in no `node_modules`.
  */
 function scriptConfigurations(host: Host, root: string, dir: string): readonly string[] {
-  let scripts: unknown;
-  try {
-    const manifest: unknown = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
-    scripts = isRecord(manifest) ? manifest["scripts"] : undefined;
-  } catch {
-    return [];
-  }
+  const scripts = manifestAt(host, dir)?.["scripts"];
   if (!isRecord(scripts)) {
     return [];
   }
@@ -270,15 +158,6 @@ function scriptConfigurations(host: Host, root: string, dir: string): readonly s
   return found;
 }
 
-/** The decoded value of one JSON file, or undefined where it cannot be read or parsed. */
-function readDocument(host: Host, path: string): unknown {
-  try {
-    return JSON.parse(host.readFile(path)) as unknown;
-  } catch {
-    return undefined;
-  }
-}
-
 /** The configuration files one project holds and sits beside. */
 interface ConfigurationFiles {
   /**
@@ -346,10 +225,10 @@ export function configurationFiles(
 ): ConfigurationFiles {
   const root = resolvePath(host.workingDirectory(), targetRoot);
   const manifests = new Map<string, boolean>();
-  const holdsManifest = (dir: string): boolean => {
+  const manifestHeld = (dir: string): boolean => {
     let held = manifests.get(dir);
     if (held === undefined) {
-      held = host.kindOf(joinPath(dir, MANIFEST)) === "file";
+      held = holdsManifest(host, dir);
       manifests.set(dir, held);
     }
     return held;
@@ -360,34 +239,24 @@ export function configurationFiles(
   for (const file of files.byPath.values()) {
     const form = configurationModuleForm(basename(file.fileName));
     const fileDir = dirnamePath(file.fileName);
-    if (form !== undefined && holdsManifest(fileDir)) {
+    if (form !== undefined && manifestHeld(fileDir)) {
       modules.push({ file, form, manifestDir: fileDir });
     }
-    for (
-      let dir = dirnamePath(file.fileName);
-      relativePath(root, dir) !== undefined && !dirs.has(dir);
-      dir = dirnamePath(dir)
-    ) {
+    for (const dir of ancestors(dirnamePath(file.fileName), root)) {
+      if (dirs.has(dir)) {
+        break;
+      }
       dirs.add(dir);
     }
   }
 
   const pending: { path: string; manifestDir: string }[] = [];
   const named: { path: string; manifestDir: string }[] = [];
-  for (const dir of [...dirs].sort()) {
-    if (!holdsManifest(dir)) {
+  for (const dir of [...dirs].sort(bytewise)) {
+    if (!manifestHeld(dir)) {
       continue;
     }
-    let names: readonly string[];
-    try {
-      names = host
-        .readDirectory(dir)
-        .filter((entry) => !entry.directory && isConfigurationDocumentName(entry.name))
-        .map((entry) => entry.name)
-        .sort();
-    } catch {
-      names = [];
-    }
+    const names = filesIn(host, dir, isConfigurationDocumentName);
     pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
     for (const path of scriptConfigurations(host, root, dir)) {
       const held = files.byName.get(path);
@@ -410,7 +279,7 @@ export function configurationFiles(
       continue;
     }
     if (document === undefined) {
-      const value = readDocument(host, next.path);
+      const value = readJSON(host, next.path);
       if (value === undefined) {
         unreadable.add(next.path);
         continue;
@@ -438,7 +307,7 @@ export function configurationFiles(
     outside:
       parse === undefined
         ? []
-        : outsideModules(host, root, [...dirs], files, holdsManifest, parse, named),
+        : outsideModules(host, root, [...dirs], files, manifestHeld, parse, named),
   };
 }
 
@@ -551,25 +420,16 @@ function outsideModules(
   root: string,
   dirs: readonly string[],
   files: SourceFiles,
-  holdsManifest: (dir: string) => boolean,
+  manifestHeld: (dir: string) => boolean,
   parse: ParseFile,
   named: readonly { readonly path: string; readonly manifestDir: string }[],
 ): readonly OutsideModule[] {
   const pending: { path: string; manifestDir: string }[] = [...named];
-  for (const dir of [...dirs].sort()) {
-    if (!holdsManifest(dir)) {
-      continue;
-    }
-    let names: readonly string[];
-    try {
-      names = host
-        .readDirectory(dir)
-        .filter((entry) => !entry.directory && configurationModuleForm(entry.name) !== undefined)
-        .map((entry) => entry.name)
-        .sort();
-    } catch {
+  for (const dir of [...dirs].sort(bytewise)) {
+    if (!manifestHeld(dir)) {
       continue;
     }
+    const names = filesIn(host, dir, (name) => configurationModuleForm(name) !== undefined);
     pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
   }
   const found = new Map<string, { file: SourceFile; manifestDirs: string[] }>();
@@ -607,17 +467,12 @@ function outsideModules(
 
 /** Every dependency the manifest in one directory declares, or none where it holds none to read. */
 export function declaredIn(host: Host, dir: string): readonly string[] {
-  let value: unknown;
-  try {
-    value = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
-  } catch {
-    return [];
-  }
-  if (!isRecord(value)) {
+  const value = manifestAt(host, dir);
+  if (value === undefined) {
     return [];
   }
   const names = new Set<string>();
-  for (const member of DEPENDENCY_MEMBERS) {
+  for (const member of DEPENDENCY_SECTIONS) {
     const section = value[member];
     if (isRecord(section)) {
       Object.keys(section).forEach((name) => names.add(name));