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

package/src/{workspace-programs.ts → load/workspace-programs.ts}

@@ -16,13 +16,14 @@ 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";
+import type { Host } from "../host.ts";
+import { dirnamePath, resolvePath } from "../paths.ts";
+import type { Engine, ProgramBuild } from "../session.ts";
 import type { WorkspaceResolver } from "./workspace-resolution.ts";
-import { bytewise } from "./text/compare.ts";
-import { PRODUCT } from "./product.ts";
+import { bytewise } from "../text/compare.ts";
+import { PRODUCT } from "../product.ts";
+import type { Parsed } from "./discover.ts";
+import type { Build, CompilerOptions } from "./plan.ts";
 
 /** One member import no member source answers for. */
 interface UnresolvedImport {
@@ -45,32 +46,33 @@ export interface MemberReading {
   readonly componentsUnread: string | undefined;
 }
 
-/** How a snapshot reads one configuration that imports a member. */
-export type WorkspaceProgram =
-  | { readonly kind: "program"; readonly params: CreateSnapshotProgramParams }
-  /** A configuration only the snapshot holds, at a path no file has. */
-  | { readonly kind: "configuration"; readonly file: string; readonly text: string };
+/** One configuration as a written configuration or a described program. */
+type Written = Exclude<Build, { readonly kind: "project" }>;
 
 /** The programs one run builds instead of opening projects, with what reading them did. */
 interface WorkspacePrograms {
   /** Per configuration that imports a member, how the snapshot reads it. */
-  readonly programs: ReadonlyMap<string, WorkspaceProgram>;
+  readonly programs: ReadonlyMap<string, Written>;
   readonly readings: readonly MemberReading[];
 }
 
-type Parsed = ReturnType<Engine["parseConfigFile"]>;
+/** One configuration the rounds read: its parse and the options the plan builds it with. */
+export interface PlannedConfiguration {
+  readonly configFile: string;
+  readonly parsed: Parsed;
+  readonly options: CompilerOptions;
+}
 
 /** The most questions one round trip carries. */
 const BATCH = 2048;
 
 /**
- * The options a configuration's program is built with: its own, less the ones that
- * lay out an emitted program's inputs and outputs, 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.
+ * The options a configuration's program is built with: the plan's, less the ones that lay
+ * out an emitted program's inputs and outputs. The analysis emits nothing, and a member's
+ * source is outside the importer's root directory by construction, which the compiler
+ * refuses under such a layout.
  */
-function analysisOptions(parsed: Parsed): CreateSnapshotProgramParams["compilerOptions"] {
+function analysisOptions(options: CompilerOptions): CreateSnapshotProgramParams["compilerOptions"] {
   const {
     composite,
     rootDir: _rootDir,
@@ -78,10 +80,8 @@ function analysisOptions(parsed: Parsed): CreateSnapshotProgramParams["compilerO
     declarationDir: _declarationDir,
     tsBuildInfoFile: _tsBuildInfoFile,
     ...kept
-  } = parsed.options;
-  const paths = baseUrlPaths(parsed.options);
-  const options = paths === undefined ? kept : { ...kept, paths };
-  return composite === true ? { ...options, declaration: true } : options;
+  } = options;
+  return composite === true ? { ...kept, declaration: true } : kept;
 }
 
 /** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
@@ -103,9 +103,7 @@ function resolutionMode(kind: ModuleKind): ResolutionMode | undefined {
 }
 
 /** One configuration's state across the rounds. */
-interface Reading {
-  readonly configFile: string;
-  readonly parsed: Parsed;
+interface Reading extends PlannedConfiguration {
   readonly entries: ModuleResolutionEntry[];
   readonly seen: Set<string>;
   /** Per member specifier, every file an import of it is read as. */
@@ -149,16 +147,17 @@ function configurationOf(
   engine: Engine,
   host: Host,
   reading: Reading,
-): WorkspaceProgram | { readonly kind: "unread"; readonly reason: string } {
+): Written | { readonly kind: "unread"; readonly reason: string } {
   const reason = unstatable(reading);
   if (reason !== undefined) {
     return { kind: "unread", reason };
   }
-  const { options, projectReferences: references = [] } = reading.parsed;
+  const { options } = reading;
+  const references = reading.parsed.projectReferences ?? [];
   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(baseUrlPaths(options) ?? options.paths ?? {})) {
+  for (const [key, targets] of Object.entries(options.paths ?? {})) {
     paths[key] = targets.map((target) => resolvePath(base, target));
   }
   for (const entry of reading.entries) {
@@ -204,7 +203,7 @@ function configurationOf(
       };
     }
   }
-  return { kind: "configuration", file, text: `${JSON.stringify(value, null, 2)}\n` };
+  return { kind: "configuration", value };
 }
 
 /** The program one configuration is built as, under the answers it holds so far. */
@@ -212,7 +211,7 @@ function programOf(
   engine: Engine,
   reading: Reading,
 ): { readonly params: CreateSnapshotProgramParams; readonly resolver: ModuleResolver } {
-  const compilerOptions = analysisOptions(reading.parsed);
+  const compilerOptions = analysisOptions(reading.options);
   const references = reading.parsed.projectReferences ?? [];
   const resolver = engine.createModuleResolver(compilerOptions, reading.entries);
   return {
@@ -338,6 +337,23 @@ type Built =
     }
   | { readonly kind: "configuration"; readonly file: string; readonly text: string };
 
+function configurationText(value: Readonly<Record<string, unknown>>): string {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+/** One configuration value as the snapshot holds it, beside the configuration it stands for. */
+export function writtenConfiguration(
+  host: Host,
+  configFile: string,
+  value: Readonly<Record<string, unknown>>,
+): Extract<ProgramBuild, { readonly kind: "configuration" }> {
+  return {
+    kind: "configuration",
+    file: writtenPath(host, configFile),
+    text: configurationText(value),
+  };
+}
+
 /**
  * Answers the member imports of every reading `build` describes, round by round, all
  * the readings still adding answers built in one snapshot per round. A reading `build`
@@ -393,28 +409,16 @@ function readRounds(
 export function workspacePrograms(
   engine: Engine,
   host: Host,
-  configFiles: readonly string[],
+  configurations: readonly PlannedConfiguration[],
   resolver: WorkspaceResolver,
 ): WorkspacePrograms {
-  const readings: Reading[] = configFiles.flatMap((configFile) => {
-    let parsed: Parsed;
-    try {
-      parsed = engine.parseConfigFile(configFile);
-    } catch {
-      // A configuration that does not read is opened as a project, which states why.
-      return [];
-    }
-    return [
-      {
-        configFile,
-        parsed,
-        entries: [],
-        seen: new Set<string>(),
-        bound: new Map<string, Set<string>>(),
-        unresolved: [],
-      },
-    ];
-  });
+  const readings: Reading[] = configurations.map((configuration) => ({
+    ...configuration,
+    entries: [],
+    seen: new Set<string>(),
+    bound: new Map<string, Set<string>>(),
+    unresolved: [],
+  }));
   readRounds(engine, readings, resolver, (reading) => ({
     kind: "program",
     ...programOf(engine, reading),
@@ -422,10 +426,12 @@ export function workspacePrograms(
   if (engine.readsComponents) {
     readRounds(engine, readings, resolver, (reading) => {
       const one = configurationOf(engine, host, reading);
-      return one.kind === "configuration" ? one : undefined;
+      return one.kind === "configuration"
+        ? writtenConfiguration(host, reading.configFile, one.value)
+        : undefined;
     });
   }
-  const programs = new Map<string, WorkspaceProgram>();
+  const programs = new Map<string, Written>();
   const unread = new Map<string, string>();
   for (const reading of readings) {
     if (reading.entries.length === 0) {

package/src/{workspace-resolution.ts → load/workspace-resolution.ts}

@@ -7,20 +7,20 @@
  */
 
 import { emittedFrom } from "./emit-map.ts";
-import { gitIgnored } from "./git-ignore.ts";
-import type { Host } from "./host.ts";
-import {
-  ancestors,
-  dirnamePath,
-  isAbsolutePath,
-  joinPath,
-  relativePath,
-  resolvePath,
-} from "./paths.ts";
-import { satisfies } from "./version-range.ts";
+import { packageOfSpecifier } from "../dependencies.ts";
+import { gitIgnored } from "../git-ignore.ts";
+import type { Host } from "../host.ts";
+import { ancestors, dirnamePath, 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";
+import { isRecord } from "../json-document.ts";
+import { MANIFEST } from "../fs/manifest.ts";
+import {
+  dependencySpecifiers,
+  installedPackage,
+  manifestsAbove,
+  type ManifestAt,
+} from "./module-lookup.ts";
 
 /** What the compiler's own resolution answered for one import. */
 export interface DefaultResolution {
@@ -45,35 +45,9 @@ export type MemberResolution =
 /** The manifest members that name an entry point for the subpath `.` without `exports`. */
 const LEGACY_MEMBERS = ["types", "typings", "module", "main"] as const;
 
-/** The dependency members a manifest declares other packages under. */
-const DEPENDENCY_MEMBERS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-] as const;
-
 const SOURCE = /(?<!\.d)\.(?:[mc]?ts|tsx)$/u;
 const OUTPUT = /(?:\.d\.[mc]?ts|\.[mc]?js|\.jsx)$/u;
 
-/** The package name a bare specifier names, or `undefined` for any other specifier. */
-export function packageNameOf(specifier: string): string | undefined {
-  if (
-    specifier === "" ||
-    specifier.startsWith(".") ||
-    specifier.startsWith("#") ||
-    isAbsolutePath(specifier) ||
-    specifier.includes(":")
-  ) {
-    return undefined;
-  }
-  const [first, second] = specifier.split("/");
-  if (specifier.startsWith("@")) {
-    return second === undefined || second === "" ? undefined : `${first ?? ""}/${second}`;
-  }
-  return first;
-}
-
 function inside(dir: string, path: string): boolean {
   return relativePath(dir, path) !== undefined;
 }
@@ -215,51 +189,32 @@ type Linked =
 /** The member imports of one workspace, read from the members' sources. */
 export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceResolver {
   const links = new Map<string, string | undefined>();
-  /** The directory `node_modules/<name>` names from one directory, links followed. */
+  /** The directory the package `name` installed for one directory is, links followed. */
   const linkedFrom = (name: string, dir: string): string | undefined => {
     const key = `${name}\u0000${dir}`;
-    if (links.has(key)) {
-      return links.get(key);
-    }
-    const candidate = joinPath(dir, INSTALLED_PACKAGES, name);
-    let found: string | undefined;
-    if (host.kindOf(candidate) === "absent") {
-      const up = dirnamePath(dir);
-      found = up === dir ? undefined : linkedFrom(name, up);
-    } else {
+    if (!links.has(key)) {
+      const installed = installedPackage(host, dir, name);
+      let found: string | undefined;
       try {
-        found = host.realPath(candidate);
+        found = installed === undefined ? undefined : host.realPath(installed);
       } catch {
         found = undefined;
       }
+      links.set(key, found);
     }
-    links.set(key, found);
-    return found;
+    return links.get(key);
   };
 
   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
-  >();
+  const manifests = new Map<string, ManifestAt | 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);
+  const nearestManifest = (dir: string): ManifestAt | undefined => {
+    if (!manifests.has(dir)) {
+      const [nearest] = manifestsAbove(host, dir, root ?? dir);
+      manifests.set(dir, nearest);
     }
-    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;
+    return manifests.get(dir);
   };
 
   const linkOf = (candidates: readonly WorkspaceMember[], fromDir: string): Linked => {
@@ -276,11 +231,9 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     // 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 declared = (manifest === undefined ? [] : dependencySpecifiers(manifest, name)).filter(
+      (specifier) => typeof specifier === "string",
+    );
     const matched = candidates.filter((member) =>
       declared.some((specifier) => dependsOn(specifier, member, owner?.dir ?? fromDir)),
     );
@@ -383,11 +336,11 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     workspace,
     sourceOf,
     names: (specifier) => {
-      const name = packageNameOf(specifier);
+      const name = packageOfSpecifier(specifier);
       return name !== undefined && workspace.named.has(name);
     },
     resolve(specifier, fromDir, conditions, answered) {
-      const name = packageNameOf(specifier);
+      const name = packageOfSpecifier(specifier);
       const candidates = name === undefined ? undefined : workspace.named.get(name);
       if (name === undefined || candidates === undefined) {
         return { kind: "default" };

package/src/{workspace-run.ts → load/workspace-run.ts}

@@ -5,24 +5,26 @@
  * the members' manifests name. A target in no workspace reads none of it.
  */
 
-import type { LocatedDiagnostic } from "./discover.ts";
-import type { Host } from "./host.ts";
-import type { Manifest, ManifestEntry } from "./manifest.ts";
-import { relativePath } from "./paths.ts";
-import type { Engine } from "./session.ts";
-import { findWorkspace, referenceOnlyIn, type ParsedLayout } from "./workspace.ts";
+import type { Host } from "../host.ts";
+import type { Manifest, ManifestEntry } from "../manifest.ts";
+import { relativePath } from "../paths.ts";
+import type { Engine } from "../session.ts";
+import type { LocatedDiagnostic } from "./diagnostics.ts";
+import type { Build } from "./plan.ts";
+import { findWorkspace, referenceOnlyIn, type ParsedLayout, type Workspace } from "./workspace.ts";
 import { memberEntries, targetManifestIn } from "./workspace-manifests.ts";
 import {
   workspacePrograms,
   type MemberReading,
-  type WorkspaceProgram,
+  type PlannedConfiguration,
 } from "./workspace-programs.ts";
 import { workspaceResolver } from "./workspace-resolution.ts";
 
 /** One run's workspace. */
-interface WorkspaceRun {
+export interface WorkspaceRun {
+  readonly workspace: Workspace;
   /** Per configuration that imports a member, how the snapshot reads it. */
-  readonly programs: ReadonlyMap<string, WorkspaceProgram>;
+  readonly programs: ReadonlyMap<string, Exclude<Build, { readonly kind: "project" }>>;
   /**
    * Per configuration whose component files the run cannot read, the reason, in the
    * order the configurations are named.
@@ -96,7 +98,7 @@ export function workspaceRun(
   engine: Engine,
   host: Host,
   targetRoot: string,
-  configFiles: readonly string[],
+  configurations: readonly PlannedConfiguration[],
   manifest: Manifest,
 ): WorkspaceRun | undefined {
   const workspace = findWorkspace(host, targetRoot, (configFile) => layoutOf(engine, configFile));
@@ -104,7 +106,7 @@ export function workspaceRun(
     return undefined;
   }
   const resolver = workspaceResolver(host, workspace);
-  const read = workspacePrograms(engine, host, configFiles, resolver);
+  const read = workspacePrograms(engine, host, configurations, resolver);
   const readings = new Map(read.readings.map((reading) => [reading.configFile, reading]));
   const referenceOnly = (
     configFile: string,
@@ -115,6 +117,7 @@ export function workspaceRun(
       new Set([...(readings.get(configFile)?.fileNames ?? []), ...compiled]),
     );
   return {
+    workspace,
     programs: read.programs,
     componentsUnread: read.readings.flatMap(({ configFile, componentsUnread }) =>
       componentsUnread === undefined ? [] : [{ configFile, reason: componentsUnread }],

package/src/{workspace.ts → load/workspace.ts}

@@ -1,29 +1,28 @@
 /**
  * The workspace a target sits in: the packages `pnpm-workspace.yaml` or a manifest's
- * `workspaces` declares in the nearest directory at or above the target root, up to
- * its repository root, where its patterns name the package the target is in, each
- * with the compiler configurations in its directory. A
- * member is the workspace root or a directory the patterns name that holds a named
- * manifest, never one below `node_modules`.
+ * `workspaces` declares in the nearest directory at or above the target root, up to its
+ * repository root, where its patterns name the package the target is in, each with the
+ * compiler configurations in its directory.
  */
 
-import { DiscoveryError, isConfigFile } from "./discover.ts";
+import { isConfigFile } from "./discover.ts";
+import { failureExit } from "../failure.ts";
 import type { EmitLayout } from "./emit-map.ts";
 import { commonDirectory } from "./emit-map.ts";
-import type { Host } from "./host.ts";
-import { ancestors, dirnamePath, joinPath, relativePath } from "./paths.ts";
-import { bytewise } from "./text/compare.ts";
-import { isRecord } from "./json-document.ts";
-import { directoriesIn, filesIn, repositoryOf } from "./fs/tree.ts";
+import type { Host } from "../host.ts";
+import { ancestors, dirnamePath, joinPath, relativePath } from "../paths.ts";
+import { bytewise } from "../text/compare.ts";
+import { isRecord } from "../json-document.ts";
+import { directoriesIn, filesIn, repositoryOf } from "../fs/tree.ts";
 import {
   holdsManifest,
   inInstalledPackages,
   INSTALLED_PACKAGES,
   MANIFEST,
   manifestAt,
-} from "./fs/manifest.ts";
-import { braceExpanded, pathMatches, segmentMatches } from "./text/glob.ts";
-import { yamlKey } from "./text/yaml.ts";
+} from "../fs/manifest.ts";
+import { braceExpanded, pathMatches, segmentMatches } from "../text/glob.ts";
+import { yamlKey } from "../text/yaml.ts";
 
 /** What one compiler configuration of a member says about where it reads and writes. */
 export interface ParsedLayout {
@@ -56,6 +55,8 @@ export interface WorkspaceMember {
 
 /** The workspace one target sits in. */
 export interface Workspace {
+  /** The directory that declares the workspace, absolute. */
+  readonly root: string;
   /** Every member, the root first, then by directory. */
   readonly members: readonly WorkspaceMember[];
   /** The members one package name names; two members may share a name. */
@@ -84,9 +85,9 @@ function declarationAt(
     if (!Array.isArray(listed) || !listed.every((entry) => typeof entry === "string")) {
       const reason =
         read.kind === "refused" ? read.reason : "packages is not a sequence of strings";
-      throw new DiscoveryError(
-        `${pnpm}: ${reason}; the workspace's packages are read from a sequence of strings`,
-        [],
+      throw failureExit(
+        "no-program",
+        `${pnpm}: ${reason}; the workspace's packages are read from a sequence of strings: correct the declaration`,
       );
     }
     return { file: pnpm, patterns: listed };
@@ -98,9 +99,9 @@ function declarationAt(
   const declared = manifest["workspaces"];
   const list = isRecord(declared) ? declared["packages"] : declared;
   if (!Array.isArray(list) || !list.every((entry) => typeof entry === "string")) {
-    throw new DiscoveryError(
-      `${joinPath(dir, MANIFEST)}: workspaces is neither an array of strings nor an object whose packages is one`,
-      [],
+    throw failureExit(
+      "no-program",
+      `${joinPath(dir, MANIFEST)}: workspaces is neither an array of strings nor an object whose packages is one: correct the declaration`,
     );
   }
   return { file: joinPath(dir, MANIFEST), patterns: list };
@@ -291,12 +292,14 @@ function nearestDeclaration(
  * from the target root up to its repository root declares one with a member beside
  * its root, or the nearest one does not name the highest package below it, at or
  * above the target root, among its members. `parse` reads one compiler configuration,
- * or answers `undefined` where it does not read.
+ * or answers `undefined` where it does not read. `known`, a workspace already read, is the
+ * answer where the nearest declaration is its own, so its members are not listed again.
  */
 export function findWorkspace(
   host: Host,
   targetRoot: string,
   parse: (configFile: string) => ParsedLayout | undefined,
+  known?: Workspace,
 ): Workspace | undefined {
   const declared = nearestDeclaration(host, targetRoot);
   if (declared === undefined) {
@@ -308,6 +311,9 @@ export function findWorkspace(
   ) {
     return undefined;
   }
+  if (known?.root === declared.root) {
+    return known;
+  }
   const members: WorkspaceMember[] = [];
   for (const dir of memberDirectories(host, declared.root, declared.patterns)) {
     const manifest = manifestAt(host, dir);
@@ -347,6 +353,7 @@ export function findWorkspace(
     return found;
   };
   return {
+    root: declared.root,
     members,
     named,
     memberOf: (path) => {

package/src/outside-tests.ts

@@ -20,7 +20,7 @@ import {
   type SourceFile,
 } from "@typescript/native/ast";
 import { RESOLVED_EXTENSIONS, type ParseFile } from "./configuration-files.ts";
-import { emittedFrom } from "./emit-map.ts";
+import { emittedFrom } from "./load/emit-map.ts";
 import type { Host } from "./host.ts";
 import type { Inventory } from "./inventory.ts";
 import { namesImported } from "./module-declarations.ts";

package/src/partial.ts

@@ -1,4 +1,4 @@
-import type { NotBuilt } from "./discover.ts";
+import type { NotBuilt } from "./load/discover.ts";
 import { relativePath } from "./paths.ts";
 import type { UnansweredQuestion } from "./query.ts";
 import { bytewise } from "./text/compare.ts";

package/src/print.ts

@@ -1,97 +1,16 @@
-import {
-  renderOrigin,
-  type Config,
-  type DeclarationEntry,
-  type Provenance,
-  type Provider,
-} from "./config.ts";
+import { renderOrigin, type Provenance, type ResolvedConfig } from "./config.ts";
 import { bytewise } from "./text/compare.ts";
 
-/** One declaration entry as a document writes it: the members of its shape alone. */
-function declarationOf(entry: DeclarationEntry): Record<string, string> {
-  switch (entry.shape) {
-    case "symbol":
-      return { symbol: entry.symbol };
-    case "module":
-      return { module: entry.module, name: entry.name };
-    case "global":
-      return { global: entry.global };
-  }
-}
-
-/** One provider entry as a document writes it: the members of its shape alone. */
-function providerOf(entry: Provider): Record<string, unknown> {
-  const installed = { name: entry.name, languages: entry.languages, command: entry.command };
-  if (entry.shape === "installed") {
-    return installed;
-  }
-  return { ...installed, source: entry.source, version: entry.version, digest: entry.digest };
-}
-
 /**
- * The resolved configuration and its provenance as one JSON object, indented,
- * ending in a newline.
- *
- * The output is an instance of the closed key list, so reading it back as a
- * repository configuration resolves to the same configuration: the provenance
- * object is a declared key resolution ignores. Keys are written in the schema's
- * order and the severity and provenance objects in ascending key order, so one
- * configuration renders to one string whatever order a source named its settings
- * in.
+ * The resolved configuration and its provenance as one JSON object, indented, ending
+ * in a newline: the configuration in the order resolution gives it, then the provenance
+ * object in ascending key order. Read back as a repository configuration it resolves to
+ * the same configuration, because resolution checks the provenance object and then
+ * ignores it.
  */
-export function printConfig(config: Config, provenance: Provenance): string {
-  const document = {
-    contract_version: config.contractVersion,
-    target: { kind: config.targetKind },
-    analysis: {
-      languages: config.analysis.languages,
-      min_confidence: config.analysis.minConfidence,
-      generated_files: config.analysis.generatedFiles,
-      consumer_tests: config.analysis.consumerTests,
-      configurations: config.analysis.configurations.map((entry) =>
-        entry.shape === "project"
-          ? { id: entry.id, project: entry.project }
-          : { id: entry.id, os: entry.os, arch: entry.arch, tags: entry.tags },
-      ),
-      matrix: { complete: config.analysis.matrixComplete },
-      template_dirs: config.analysis.templateDirs,
-      template_delimiters: {
-        left: config.analysis.templateDelimiters.left,
-        right: config.analysis.templateDelimiters.right,
-      },
-    },
-    consumers: { complete: config.consumersComplete },
-    roots: { patterns: config.rootPatterns },
-    severity: Object.fromEntries([...config.severity].sort(([a], [b]) => bytewise(a, b))),
-    exemptions: { disabled: config.exemptionsDisabled },
-    reporters: {
-      formats: config.reporters.formats,
-      sort: config.reporters.sort,
-      cascade: config.reporters.cascade,
-      max_findings: config.reporters.maxFindings,
-      fail_on: config.reporters.failOn,
-    },
-    providers: { analyzers: config.providers.analyzers.map(providerOf) },
-    go: {},
-    ts: {
-      test_files: config.ts.testFiles,
-      entry_files: config.ts.entryFiles,
-      component_extensions: config.ts.componentExtensions,
-      disabled_conventions: config.ts.disabledConventions,
-      injection_registrations: config.ts.injectionRegistrations.map(declarationOf),
-      lifecycle_contracts: config.ts.lifecycleContracts.map((entry) => ({
-        components: entry.components.map(declarationOf),
-        bases: entry.bases.map(declarationOf),
-        members: entry.members,
-      })),
-      serializers: config.ts.serializers.map(declarationOf),
-      roots_complete: config.ts.rootsComplete,
-    },
-    provenance: Object.fromEntries(
-      [...provenance]
-        .sort(([a], [b]) => bytewise(a, b))
-        .map(([path, origin]) => [path, renderOrigin(origin)]),
-    ),
-  };
-  return `${JSON.stringify(document, undefined, 2)}\n`;
+export function printConfig(config: ResolvedConfig, provenance: Provenance): string {
+  const origins = [...provenance]
+    .sort(([a], [b]) => bytewise(a, b))
+    .map(([path, origin]): [string, string] => [path, renderOrigin(origin)]);
+  return `${JSON.stringify({ ...config, provenance: Object.fromEntries(origins) }, undefined, 2)}\n`;
 }