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

package/src/contract/report.generated.ts

@@ -589,7 +589,7 @@ export const REPORT_SCHEMAS = {
           additionalProperties: false,
           required: ["edge", "side", "symbol", "state"],
           properties: {
-            edge: { type: "string", pattern: "^[A-Za-z0-9_.-]+(/[A-Za-z0-9_.-]+)*$" },
+            edge: { $ref: "finding.schema.json#/$defs/edge_identifier" },
             side: { type: "string", enum: ["provides", "used_by"] },
             symbol: { type: "string" },
             state: { type: "string", enum: ["live", "dead", "absent"] },
@@ -969,7 +969,7 @@ export const REPORT_SCHEMAS = {
             uniqueItems: true,
             items: { type: "string", minLength: 1 },
           },
-          edge: { type: "string", pattern: "^[A-Za-z0-9_.-]+(/[A-Za-z0-9_.-]+)*$" },
+          edge: { $ref: "#/$defs/edge_identifier" },
           sides: {
             type: "array",
             minItems: 1,
@@ -1125,6 +1125,7 @@ export const REPORT_SCHEMAS = {
       },
     ],
     $defs: {
+      edge_identifier: { type: "string", pattern: "^[A-Za-z0-9_.-]+(/[A-Za-z0-9_.-]+)*$" },
       position: {
         type: "object",
         additionalProperties: false,

package/src/discover.ts

@@ -504,7 +504,7 @@ export function discoverProjects(
   configurations: readonly BuildConfiguration[] = [],
 ): Discovery {
   const declared = configurations.filter(
-    (entry): entry is ProjectConfiguration => entry.shape === "project",
+    (entry): entry is ProjectConfiguration => "project" in entry,
   );
   if (declared.length > 0) {
     return declaredProjects(engine, host, scope.target.path, declared);

package/src/edges.ts

@@ -5,17 +5,18 @@
  * pairing is a use, and the merge reads the two evaluations together.
  */
 
-import { ConfigError } from "./config.ts";
+import { EDGES_SCHEMA } from "./contract/config.generated.ts";
 import type { Finding } from "./finding.ts";
 import type { EdgeSide, EdgeSideName } from "./findings/boundary.ts";
+import { readTargetDocument } from "./fs/document.ts";
 import type { Host } from "./host.ts";
 import type { InventorySymbol } from "./inventory.ts";
-import { isRecord, positionAt, walkDocument } from "./json-document.ts";
-import { joinPath } from "./paths.ts";
+import { dotted, placeIn, positionAt, readStrict, StrictJSONError } from "./json-document.ts";
 import { positionKey } from "./position.ts";
+import { firstRefusal } from "./schema.ts";
 import { isPartSubject } from "./suppress.ts";
 import { bytewise } from "./text/compare.ts";
-import { message } from "./product.ts";
+import { UsageError } from "./usage.ts";
 
 /** The name and the location the Contract fixes for the edges document. */
 export const EDGES_FILE = "deadset-edges.json";
@@ -23,147 +24,61 @@ export const EDGES_FILE = "deadset-edges.json";
 /** The language prefix of every reference this analyzer evaluates. */
 const OWN_PREFIX = "ts://";
 
-/** The closed key list of the document and of one edge. */
-const DOCUMENT_KEYS: ReadonlySet<string> = new Set(["description", "edges"]);
-const EDGE_KEYS: ReadonlySet<string> = new Set(["id", "because", "provides", "used_by"]);
-
-/** An edge identifier: solidus-separated segments of ASCII letters, digits, `_`, `.` and `-`. */
-const ID_FORM = /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*$/u;
-
-/** A reference naming one symbol of some language: `<language>://<scope>#<fragment>`. */
-const REFERENCE_FORM = /^[a-z][a-z0-9]*:\/\/[^ \t\r\n#]+#[^ \t\r\n]*$/u;
-
-const DOCUMENT_WANT = "an object carrying the edges array, and an optional description";
-const EDGE_WANT = "an edge naming id, provides and used_by, each a string, and an optional because";
-const ID_WANT =
-  "one or more solidus-separated segments of ASCII letters, digits, underscore, full stop and hyphen";
-const REFERENCE_WANT =
-  "a stable symbol reference naming one symbol exactly, <language>://<scope>#<fragment>";
-
 /** An edges document the Contract refuses: a malformed input, answered with the usage code. */
-class EdgesError extends ConfigError {
-  constructor(at: string, text: string, want: string) {
-    super("malformed", EDGES_FILE, `${at}: ${text}: want ${want}`);
+class EdgesError extends UsageError {
+  constructor(at: string, reason: string) {
+    super(`${at}: ${reason}`);
     this.name = "EdgesError";
   }
 }
 
-/**
- * Whether a reference carries a wildcard outside a quoted or a computed component, which
- * would name a set of symbols rather than one.
- */
-function carriesWildcard(ref: string): boolean {
-  let quoted = false;
-  let computed = false;
-  let escaped = false;
-  for (const char of ref) {
-    if (escaped) {
-      escaped = false;
-    } else if (quoted && char === "\\") {
-      escaped = true;
-    } else if (quoted) {
-      quoted = char !== "'";
-    } else if (computed) {
-      computed = char !== "]";
-    } else if (char === "'") {
-      quoted = true;
-    } else if (char === "[") {
-      computed = true;
-    } else if (char === "*") {
-      return true;
-    }
-  }
-  return false;
-}
-
-/** One edge, checked: the closed key list, the value types and the value forms. */
-function readEdge(value: unknown, at: string): { id: string; provides: string; usedBy: string } {
-  const refuse = (text: string, want: string): never => {
-    throw new EdgesError(at, text, want);
-  };
-  if (!isRecord(value)) {
-    return refuse(JSON.stringify(value), EDGE_WANT);
-  }
-  for (const [key, held] of Object.entries(value)) {
-    if (!EDGE_KEYS.has(key) || typeof held !== "string") {
-      refuse(`the member ${JSON.stringify(key)} holding ${JSON.stringify(held)}`, EDGE_WANT);
-    }
-  }
-  const edge = value as Readonly<Record<string, string | undefined>>;
-  const id = edge["id"] ?? refuse("an edge naming no id", EDGE_WANT);
-  const provides = edge["provides"] ?? refuse("an edge naming no provides side", EDGE_WANT);
-  const usedBy = edge["used_by"] ?? refuse("an edge naming no used_by side", EDGE_WANT);
-  if (!ID_FORM.test(id)) {
-    refuse(JSON.stringify(id), ID_WANT);
-  }
-  for (const ref of [provides, usedBy]) {
-    if (!REFERENCE_FORM.test(ref) || carriesWildcard(ref)) {
-      refuse(JSON.stringify(ref), REFERENCE_WANT);
-    }
-  }
-  return { id, provides, usedBy };
-}
+/** The sides of one edge, in the order a reader yields them. */
+const SIDE_NAMES: readonly EdgeSideName[] = ["provides", "used_by"];
 
 /**
  * Every side of a declared edge that names a symbol of this language, in document order,
  * `provides` before `used_by` within an edge. An absent document declares no edge. The
- * document is strict JSON with a closed key list at both levels, and a defect in it is an
- * {@link EdgesError}.
+ * document is strict JSON held to the Contract's edges schema, and a defect in it is an
+ * {@link EdgesError} at the line and column of the edge it is in, where it is in one.
  */
 export function readEdgeSides(host: Host, targetRoot: string): readonly EdgeSide[] {
-  const file = joinPath(targetRoot, EDGES_FILE);
-  if (host.kindOf(file) === "absent") {
+  const text = readTargetDocument(host, targetRoot, EDGES_FILE);
+  if (text === undefined) {
     return [];
   }
-  const text = host.readFile(file);
-  let parsed: unknown;
+  let read;
   try {
-    parsed = JSON.parse(text);
+    read = readStrict(text, "edges");
   } catch (error: unknown) {
-    throw new EdgesError(EDGES_FILE, message(error), DOCUMENT_WANT);
-  }
-  if (!isRecord(parsed)) {
-    throw new EdgesError(EDGES_FILE, JSON.stringify(parsed), DOCUMENT_WANT);
-  }
-  const walk = walkDocument(text, "edges");
-  if (walk.twice !== undefined) {
-    throw new EdgesError(
-      positionKey(positionAt(text, EDGES_FILE, walk.twice.offset)),
-      `the member ${JSON.stringify(walk.twice.name)} is written twice, so neither value is chosen`,
-      DOCUMENT_WANT,
-    );
+    if (!(error instanceof StrictJSONError)) {
+      throw error;
+    }
+    throw new EdgesError(positionKey(positionAt(text, EDGES_FILE, error.offset)), error.message);
   }
-  const unknown = Object.keys(parsed).find((key) => !DOCUMENT_KEYS.has(key));
-  const description = parsed["description"];
-  const edges = parsed["edges"];
-  if (
-    unknown !== undefined ||
-    (description !== undefined && typeof description !== "string") ||
-    !Array.isArray(edges)
-  ) {
-    throw new EdgesError(
-      EDGES_FILE,
-      unknown === undefined ? EDGES_FILE : `the member ${JSON.stringify(unknown)}`,
-      DOCUMENT_WANT,
-    );
+  const value = read.value;
+  const refused = firstRefusal(EDGES_SCHEMA, value);
+  if (refused !== undefined) {
+    const place = placeIn(value, refused.pointer, refused.member);
+    const offset = place.length > 1 ? read.starts.get(place[1] ?? "") : undefined;
+    const at =
+      offset === undefined ? EDGES_FILE : positionKey(positionAt(text, EDGES_FILE, offset));
+    const where = dotted(place);
+    throw new EdgesError(at, where === "" ? refused.reason : `${where}: ${refused.reason}`);
   }
+  const edges = (
+    value as { readonly edges: Readonly<Record<string, Record<EdgeSideName, string>>> }
+  ).edges;
 
   const sides: EdgeSide[] = [];
-  (edges as readonly unknown[]).forEach((value, index) => {
-    const offset = walk.starts[index];
-    const at =
-      offset === undefined ? EDGES_FILE : positionKey(positionAt(text, EDGES_FILE, offset));
-    const edge = readEdge(value, at);
-    const named: readonly [EdgeSideName, string][] = [
-      ["provides", edge.provides],
-      ["used_by", edge.usedBy],
-    ];
-    for (const [side, symbol] of named) {
-      if (symbol.startsWith(OWN_PREFIX)) {
-        sides.push({ edge: edge.id, side, symbol });
+  for (const id of read.starts.keys()) {
+    const edge = String(id);
+    for (const side of SIDE_NAMES) {
+      const symbol = edges[edge]?.[side];
+      if (symbol?.startsWith(OWN_PREFIX) === true) {
+        sides.push({ edge, side, symbol });
       }
     }
-  });
+  }
   return sides;
 }
 

package/src/exempt-classes.ts

@@ -47,8 +47,3 @@ const VISIBILITY: ReadonlyMap<TSExemptionClass, TypeScriptVisibility> = new Map(
 export function typescriptVisibilityOf(exemptionClass: TSExemptionClass): TypeScriptVisibility {
   return VISIBILITY.get(exemptionClass) ?? { private: false, privateName: false };
 }
-
-/** Every class of the vocabulary, whichever language it runs on, in the vocabulary's order. */
-export const EXEMPTION_CLASS_NAMES: readonly ExemptionClass[] = EXEMPTION_CLASSES.map(
-  (row) => row.class,
-);

package/src/exempt.ts

@@ -8,7 +8,7 @@
  */
 
 import { EXEMPTION_CLASSES } from "./contract/contract.generated.ts";
-import type { Config, TSSection } from "./config.ts";
+import type { ResolvedConfig } from "./config.ts";
 import {
   TS_EXEMPTION_CLASSES,
   typescriptVisibilityOf,
@@ -48,7 +48,7 @@ export interface DetectorInput<Brand> {
   /** The configured templates, read once for the run. */
   readonly templates: Templates;
   /** The `ts` section, whose declarations the configured classes read. */
-  readonly ts: TSSection;
+  readonly ts: ResolvedConfig["ts"];
   /** The absolute path of each declared consumer, whose modules are part of the analysis. */
   readonly consumers: readonly string[];
   /** The project's generated files, by path below the target root, each with the detail its retentions name. */
@@ -75,8 +75,8 @@ interface Holding {
  * The classes `exemptions.disabled` switches off. A class that runs on another language
  * only switches nothing off here, so one configuration serves every analyzer.
  */
-export function disabledClasses(config: Config): ReadonlySet<ExemptionClass> {
-  return new Set(config.exemptionsDisabled);
+export function disabledClasses(config: ResolvedConfig): ReadonlySet<ExemptionClass> {
+  return new Set(config.exemptions.disabled);
 }
 
 /**

package/src/findings/completion.ts

@@ -65,10 +65,9 @@ function everyDeclaredLoaded(boundary: Boundary): boolean {
  * naming its family, else the code's default.
  */
 function severityOf(input: EmitterInput, code: string, fallback: Severity): Severity {
-  const { config } = input;
-  return (
-    config.severity.get(code) ?? config.severity.get(code.slice(0, FAMILY_KEY_LENGTH)) ?? fallback
-  );
+  const { severity } = input.config;
+  const key = [code, code.slice(0, FAMILY_KEY_LENGTH)].find((one) => Object.hasOwn(severity, one));
+  return key === undefined ? fallback : (severity[key] ?? fallback);
 }
 
 /**
@@ -225,7 +224,7 @@ function rootsCeiling(
 ): Confidence {
   const unreachable = candidate?.relation === "reachability" || finding.unreachableOnly === true;
   const unseen = new Set((input.files.unseenLoads ?? []).map((load) => load.configuration));
-  const complete = input.config.ts.rootsComplete && !configurations.some((one) => unseen.has(one));
+  const complete = input.config.ts.roots_complete && !configurations.some((one) => unseen.has(one));
   return unreachable && !complete ? "probable" : "certain";
 }
 
@@ -585,7 +584,7 @@ export function dialsOf(
   input: EmitterInput,
   findings: readonly CompletedFinding[],
 ): Dials<CompletedFinding> {
-  const minConfidence = input.config.analysis.minConfidence;
+  const minConfidence = input.config.analysis.min_confidence;
   const components = new Set(
     findings
       .filter(

package/src/findings/emitter.ts

@@ -1,5 +1,5 @@
 import type { RunSweep } from "../analysis.ts";
-import type { Config } from "../config.ts";
+import type { ResolvedConfig } from "../config.ts";
 import type { Dependencies } from "../dependencies.ts";
 import type { FileFacts } from "../file-facts.ts";
 import type { Finding } from "../finding.ts";
@@ -14,7 +14,7 @@ import type { SelfCheckFacts } from "./self-check.ts";
  * the facts about the run each emitter reads beside the sweep.
  */
 export interface EmitterInput {
-  readonly config: Config;
+  readonly config: ResolvedConfig;
   /** The production sweep a report is built from, beside the matrix it judged. */
   readonly swept: RunSweep;
   /** The declarations carrying the deprecation marker in any configuration of the run. */

package/src/findings/emitters.ts

@@ -145,7 +145,7 @@ function atPossible(input: EmitterInput): EmitterInput {
   const { config } = input;
   return {
     ...input,
-    config: { ...config, analysis: { ...config.analysis, minConfidence: "possible" } },
+    config: { ...config, analysis: { ...config.analysis, min_confidence: "possible" } },
   };
 }
 

package/src/findings/intra-function.ts

@@ -127,7 +127,7 @@ export const intraFunction: Emitter = (input) => {
     }),
   );
   const { declared, loaded } = input.boundary.consumers;
-  const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
+  const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
   const published = (id: string): boolean => {
     const symbol = byId.get(id);
     return (

package/src/findings/non-code-artifacts.ts

@@ -1,5 +1,5 @@
 import { CODE } from "../contract/contract.generated.ts";
-import type { Config } from "../config.ts";
+import type { ResolvedConfig } from "../config.ts";
 import type { Finding } from "../finding.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
@@ -15,10 +15,10 @@ const FILE_START = 1;
  * completeness and listing no project declares it of a matrix the run derived, and a
  * derived matrix is never complete.
  */
-function completeMatrix(config: Config): boolean {
+function completeMatrix(config: ResolvedConfig): boolean {
   return (
-    config.analysis.matrixComplete &&
-    config.analysis.configurations.some((entry) => entry.shape === "project")
+    config.analysis.matrix.complete &&
+    config.analysis.configurations.some((entry) => "project" in entry)
   );
 }
 

package/src/findings/unused-declarations.ts

@@ -218,7 +218,7 @@ export const unusedDeclarations: Emitter = (input) => [
  */
 function unusedImports(input: EmitterInput): Finding[] {
   const generated =
-    input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
+    input.config.analysis.generated_files === "include" ? undefined : input.files.generated;
   return input.intraFunction.imports.flatMap((binding) =>
     binding.used || generated?.has(binding.position.path) === true
       ? []

package/src/findings/visibility-narrowing.ts

@@ -266,13 +266,13 @@ function unreachable(
 export function narrowings(input: EmitterInput): readonly Finding[] {
   const facts = factsOf(input.swept.matrix.union);
   const { declared, loaded } = input.boundary.consumers;
-  const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
+  const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
   const world = { closed, writeOnly: writeOnlyDeclarations(input) };
   const candidates = new Map(
     input.swept.sweep.candidates.map((candidate) => [candidate.id, candidate]),
   );
   const generated =
-    input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
+    input.config.analysis.generated_files === "include" ? undefined : input.files.generated;
 
   const findings: Finding[] = [];
   facts.graph.symbols.forEach((symbol, at) => {

package/src/findings-pass.ts

@@ -6,7 +6,7 @@
 
 import { EXIT_CLEAN, EXIT_FINDINGS, EXIT_PENDING } from "./contract/contract.generated.ts";
 import type { AnalysisInputs } from "./analysis.ts";
-import { fails, type Config } from "./config.ts";
+import { fails, type ResolvedConfig } from "./config.ts";
 import type { EdgeEvaluation } from "./edges.ts";
 import type { CompletedFinding, Finding } from "./finding.ts";
 import { decidedFindings, type Withheld } from "./findings/emitters.ts";
@@ -109,7 +109,7 @@ export function findingsPass(inputs: AnalysisInputs): PassResult {
  * suppression is stale or a finding's severity reaches the configured failing severity;
  * clean otherwise.
  */
-export function verdictOf(result: PassResult, config: Config): number {
+export function verdictOf(result: PassResult, config: ResolvedConfig): number {
   if (result.totals.pending > 0) {
     return EXIT_PENDING;
   }
@@ -117,7 +117,7 @@ export function verdictOf(result: PassResult, config: Config): number {
     return EXIT_FINDINGS;
   }
   const failing = result.findings.some((finding) =>
-    fails(finding.severity, config.reporters.failOn),
+    fails(finding.severity, config.reporters.fail_on),
   );
   return failing ? EXIT_FINDINGS : EXIT_CLEAN;
 }

package/src/framework-lifecycle.ts

@@ -55,8 +55,8 @@ function resolveContracts<Brand>(
   contracts: readonly LifecycleContract[],
 ): readonly ResolvedContract[] {
   const entries: DeclarationEntry[] = contracts.flatMap((contract) => [
-    ...contract.components,
-    ...contract.bases,
+    ...(contract.components ?? []),
+    ...(contract.bases ?? []),
   ]);
   const resolved = resolveEntries(project, held, entries);
   let next = 0;
@@ -67,8 +67,8 @@ function resolveContracts<Brand>(
   };
   return contracts.map((contract) => ({
     contract,
-    components: take(contract.components.length),
-    bases: take(contract.bases.length),
+    components: take(contract.components?.length ?? 0),
+    bases: take(contract.bases?.length ?? 0),
   }));
 }
 
@@ -243,11 +243,11 @@ function byBases<Brand>(
  */
 export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
   const { project, held, targetRoot } = input;
-  if (input.ts.lifecycleContracts.length === 0) {
+  if (input.ts.lifecycle_contracts.length === 0) {
     return [];
   }
   const chains = aliasChains(project, held);
-  const contracts = resolveContracts(project, held, input.ts.lifecycleContracts);
+  const contracts = resolveContracts(project, held, input.ts.lifecycle_contracts);
   const components = [
     ...byComponents(project, held, chains, contracts),
     ...byBases(project, held, chains, contracts),
@@ -256,7 +256,7 @@ export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly
     return [];
   }
   const ids = new Set(components.map((one) => one.id));
-  const sides: readonly ClassSide[] = input.ts.lifecycleContracts.some((contract) =>
+  const sides: readonly ClassSide[] = input.ts.lifecycle_contracts.some((contract) =>
     contract.members.some((name) => name.endsWith(":static")),
   )
     ? ["instance", "static"]

package/src/fs/document.ts

@@ -0,0 +1,74 @@
+/**
+ * The one read of a document the target holds at its root, which a checkout under analysis
+ * controls: the repository configuration, the ignore file, the baseline and the edges
+ * document. The read stays inside the target root, takes a regular file alone, and holds no
+ * more of it than the Contract's document bound.
+ */
+
+import { CONFIG_MAX_BYTES } from "../contract/config.generated.ts";
+import type { Host } from "../host.ts";
+import { joinPath, relativePath } from "../paths.ts";
+import { message } from "../product.ts";
+import { utf8Bytes } from "../reporters/sha256.ts";
+import { UsageError } from "../usage.ts";
+
+/**
+ * A document at the target root that is not one to read: its name resolves outside the
+ * target root or to anything but a regular file, or the read fails. Nothing is read from
+ * it, and the run ends with the failure code.
+ */
+export class TargetDocumentError extends Error {
+  constructor(label: string, reason: string) {
+    super(`${label}: ${reason}`);
+    this.name = "TargetDocumentError";
+  }
+}
+
+/** Refuses a document past the Contract's bound with the usage code, naming it `label`. */
+export function refuseOverBound(label: string, text: string): void {
+  if (utf8Bytes(text).length > CONFIG_MAX_BYTES) {
+    throw new UsageError(`${label}: holds more than ${String(CONFIG_MAX_BYTES)} bytes`);
+  }
+}
+
+/** What `read` returns, or its throw as the document's {@link TargetDocumentError}. */
+function attempt<T>(label: string, read: () => T): T {
+  try {
+    return read();
+  } catch (error: unknown) {
+    throw new TargetDocumentError(label, message(error));
+  }
+}
+
+/**
+ * The text of the document `name` at the absolute `targetRoot`, undefined where nothing is
+ * there, each refusal naming it `label`. A document past the bound is read one byte past
+ * it and refused as {@link refuseOverBound} refuses it.
+ */
+export function readTargetDocument(
+  host: Host,
+  targetRoot: string,
+  name: string,
+  label = name,
+): string | undefined {
+  const path = joinPath(targetRoot, name);
+  const kind = attempt(label, () => host.kindOf(path));
+  if (kind === "absent") {
+    return undefined;
+  }
+  const real = attempt(label, () => host.realPath(path));
+  if (
+    relativePath(
+      attempt(label, () => host.realPath(targetRoot)),
+      real,
+    ) === undefined
+  ) {
+    throw new TargetDocumentError(label, `resolves to ${real}, outside the target root`);
+  }
+  if (kind !== "file") {
+    throw new TargetDocumentError(label, "is not a regular file");
+  }
+  const text = attempt(label, () => host.readFile(real, CONFIG_MAX_BYTES + 1));
+  refuseOverBound(label, text);
+  return text;
+}

package/src/host.ts

@@ -1,5 +1,5 @@
-/** What one path names. */
-export type PathKind = "file" | "directory" | "absent";
+/** What one path names: `"other"` is anything else there, a named pipe, a device or a socket. */
+export type PathKind = "file" | "directory" | "other" | "absent";
 
 /** One entry of a directory. */
 export interface DirectoryEntry {
@@ -17,11 +17,18 @@ export interface DirectoryEntry {
 export interface Host {
   /** The directory a relative path resolves against. */
   workingDirectory(): string;
-  /** The text of one file, or a throw naming why it cannot be read. */
-  readFile(path: string): string;
+  /**
+   * The text of one file, or a throw naming why it cannot be read. Given `limit`, the
+   * text of no more than the file's first `limit` bytes, so a caller bounding a document
+   * asks for one byte past its bound and never holds a larger file whole.
+   */
+  readFile(path: string, limit?: number): string;
   /** The entries of one directory, or a throw naming why it cannot be read. */
   readDirectory(path: string): readonly DirectoryEntry[];
-  /** What one path names, `"absent"` where nothing is there. */
+  /**
+   * What one path names once every symbolic link along it is followed, `"absent"` where
+   * nothing is there, or a throw naming why it cannot be known, as for a link loop.
+   */
   kindOf(path: string): PathKind;
   /**
    * The path one path names once every symbolic link along it is followed, or a throw

package/src/injection-container.ts

@@ -53,7 +53,7 @@ function isInjected(node: Node): boolean {
 /** The classes of the target a call whose callee an entry names passes, with that call's entry. */
 function registrations<Brand>(input: DetectorInput<Brand>): readonly Registration[] {
   const { project, held } = input;
-  const resolved = resolveEntries(project, held, input.ts.injectionRegistrations);
+  const resolved = resolveEntries(project, held, input.ts.injection_registrations);
   if (!resolved.some(namesADeclaration)) {
     return [];
   }