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

package/src/analysis.ts

@@ -8,7 +8,7 @@
 
 import { isStringLiteralLikeNode, type SourceFile } from "@typescript/native/ast";
 import { lineOf, readComponent } from "./component-files.ts";
-import { kindOf, type Config, type Provenance } from "./config.ts";
+import { kindOf, type PartialConfig, type Provenance, type ResolvedConfig } from "./config.ts";
 import {
   consumerLoads,
   consumerReferences,
@@ -139,7 +139,6 @@ import { ownErrors, workspaceRun } from "./workspace-run.ts";
 import { bytewise } from "./text/compare.ts";
 import { holdsManifest, inInstalledPackages, MANIFEST, manifestAt } from "./fs/manifest.ts";
 import { globExpression } from "./text/glob.ts";
-import { LANGUAGE } from "./product.ts";
 
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
@@ -325,7 +324,7 @@ function readProjects<Answer>(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: PartialConfig,
   stage: <Brand>(project: ProjectView<Brand>, opened: OpenedProject) => Answer,
 ): ReadProjects<Answer> {
   const targetRoot = scope.target.path;
@@ -356,7 +355,7 @@ function readProjects<Answer>(
   // The nested packages are known only once every program is open, and every visit reads
   // the conventions and options they decide, so both are set in the session's first step.
   let nestedDirs: readonly string[] = [];
-  let conventions = readConventions(host, parse, [], config.ts.disabledConventions);
+  let conventions = readConventions(host, parse, [], config.ts.disabled_conventions);
   let options: RootOptions & { readonly parse: typeof parse; readonly conventions: Conventions };
   const readManifests = (opened: readonly OpenedFiles[]): void => {
     nestedDirs = nestedPackageDirs(
@@ -371,7 +370,7 @@ function readProjects<Answer>(
       host,
       parse,
       conventionManifests(host, absoluteRoot, memberDirs, nestedDirs),
-      config.ts.disabledConventions,
+      config.ts.disabled_conventions,
     );
     options = {
       host,
@@ -380,12 +379,12 @@ function readProjects<Answer>(
         ...(workspace?.entries ?? []),
         ...packageEntries(host, normalizePath(absoluteRoot), nestedDirs),
       ],
-      patterns: config.rootPatterns,
-      entryFiles: config.ts.entryFiles,
+      patterns: config.roots.patterns,
+      entryFiles: config.ts.entry_files,
       conventions,
-      testFiles: config.ts.testFiles,
+      testFiles: config.ts.test_files,
       parse,
-      publishedAPI: config.targetKind !== "" && kindOf(config.targetKind, LANGUAGE) === "library",
+      publishedAPI: config.target.kind !== undefined && kindOf(config.target.kind) === "library",
       publishedMembers: new Set(
         (workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir),
       ),
@@ -420,7 +419,7 @@ function readProjects<Answer>(
       unbuildable.push(...met);
     }
   };
-  const testPatterns = config.ts.testFiles.map(globExpression);
+  const testPatterns = config.ts.test_files.map(globExpression);
   const joins = discovered.derived
     ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
     : new Map<string, readonly string[]>();
@@ -657,7 +656,12 @@ interface RunProjects {
  * for the errors and setup failures that decide whether it is analyzed, dropped or
  * fails the run, exactly as the analysis reads them.
  */
-export function runProjects(engine: Engine, host: Host, scope: Scope, config: Config): RunProjects {
+export function runProjects(
+  engine: Engine,
+  host: Host,
+  scope: Scope,
+  config: PartialConfig,
+): RunProjects {
   const read = readProjects(
     engine,
     host,
@@ -678,7 +682,7 @@ export function runRoots(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
 ): RunRoots {
   const targetRoot = scope.target.path;
@@ -719,7 +723,7 @@ export function runRoots(
       bytewise(a.source, b.source),
   );
   const unmatched = unmatchedEverywhere(
-    config.rootPatterns,
+    config.roots.patterns,
     projects.map((answer) => answer.rooted),
   );
   return {
@@ -899,7 +903,7 @@ function readRun<Extra>(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   mode: Mode,
   detectors: Detectors,
   extra: <Brand>(
@@ -912,13 +916,13 @@ function readRun<Extra>(
   const targetRoot = scope.target.path;
   const disabled = disabledClasses(config);
   const templates = disabled.has("template-field")
-    ? { delimiters: config.analysis.templateDelimiters, files: [] }
+    ? { delimiters: config.analysis.template_delimiters, files: [] }
     : readTemplates(host, targetRoot, config.analysis);
   const consumers = scope.consumers.map((consumer) => consumer.path);
   const read = readProjects<ReadProject<Extra>>(engine, host, scope, config, (project, opened) => {
     const projectRead = opened.read();
     const resolved = references(project, projectRead.held, targetRoot, {
-      testFiles: config.ts.testFiles,
+      testFiles: config.ts.test_files,
       testFileNames: projectRead.testFileNames,
     });
     const evidence = evidenceRecords(
@@ -929,7 +933,7 @@ function readRun<Extra>(
         templates,
         ts: config.ts,
         consumers,
-        ...(config.analysis.generatedFiles === "include"
+        ...(config.analysis.generated_files === "include"
           ? {}
           : { generated: projectRead.generated }),
       },
@@ -1281,7 +1285,7 @@ export function runSweep(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   input: Pick<SweepInput, "marked" | "mode">,
   detectors: Detectors = DETECTORS,
 ): RunSweep {
@@ -1324,7 +1328,7 @@ export function readEmitterRun(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   mode: Mode,
   detectors: Detectors,
 ): ReadRun<EmitterExtra> {
@@ -1417,7 +1421,7 @@ function nearestManifestDir(host: Host, root: string, file: string): string {
 export function emitterInputOver(
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   read: ReadRun<EmitterExtra>,
   input: Pick<SweepInput, "marked" | "mode">,
   selfCheck: SelfCheckFacts,
@@ -1505,7 +1509,7 @@ function readAnalysis(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
   mode: Mode,
   detectors: Detectors,
@@ -1526,7 +1530,7 @@ function readAnalysis(
         configFile: one.configFile,
       })),
       testFileRules: testFileRulesOf(
-        config.ts.testFiles,
+        config.ts.test_files,
         read.projects.flatMap((one) => one.configured.testFiles),
         read.projects.flatMap((one) => one.configured.supportFiles ?? []),
       ),
@@ -1557,7 +1561,7 @@ function readAnalysis(
 function inputsOver(
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
   mode: Mode,
   read: ReadRun<EmitterExtra>,
@@ -1571,7 +1575,7 @@ function inputsOver(
   const facts: SelfCheckFacts = {
     refusals: suppressions.refusals,
     unmatchedRoots: unmatchedEverywhere(
-      config.rootPatterns,
+      config.roots.patterns,
       read.projects.map((one) => one.extra.rooted),
     ),
     rootsDocument: documentOf(host, provenance, ROOTS_SETTING, targetRoot),
@@ -1681,7 +1685,7 @@ export function runAnalysis(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
   mode: Mode,
   detectors: Detectors = DETECTORS,
@@ -1737,7 +1741,7 @@ export function runBaselineWrite(
   engine: Engine,
   host: Host,
   scope: Scope,
-  config: Config,
+  config: ResolvedConfig,
   provenance: Provenance,
   mode: Mode,
   reason: string,

package/src/config.ts

@@ -1,12 +1,6 @@
-import {
-  CONTRACT_VERSION,
-  type Confidence,
-  type Format,
-  type Language,
-  type Severity,
-} from "./contract/contract.generated.ts";
-import type { ExemptionClass } from "./exempt-classes.ts";
-import { LANGUAGE, PRODUCT } from "./product.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
@@ -15,254 +9,32 @@ import { LANGUAGE, PRODUCT } from "./product.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];
 }
 
-/** 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";
-
-/** 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];
-}
-
-/** 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 ExemptionClass[];
-  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: PRODUCT, languages: [LANGUAGE], command: PRODUCT },
-      ],
-    },
-    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;
@@ -277,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/configured-declarations.ts

@@ -19,7 +19,7 @@ import {
 import { SymbolFlags, type NodeHandle, type Symbol as TSSymbol } from "@typescript/native/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import { resolvedTargets } from "./calls.ts";
-import type { Config, DeclarationEntry } from "./config.ts";
+import type { DeclarationEntry, ResolvedConfig } from "./config.ts";
 import { declaredComponent, type Inventory } from "./inventory.ts";
 import { must, Unanswerable } from "./query.ts";
 import { nameComponent } from "./ref.ts";
@@ -252,21 +252,21 @@ export function resolveEntries<Brand>(
   }
   const modules = modulesNamed(
     project,
-    new Set(entries.flatMap((entry) => (entry.shape === "module" ? [entry.module] : []))),
+    new Set(entries.flatMap((entry) => ("module" in entry ? [entry.module] : []))),
   );
   return entries.map((entry) => {
-    if (entry.shape === "symbol") {
+    if ("symbol" in entry) {
       return { entry, handles: new Set<string>(), ids: new Set(byRef.get(entry.symbol) ?? []) };
     }
     const { components, static: isStatic } = componentsOf(
-      entry.shape === "module" ? entry.name : entry.global,
+      "module" in entry ? entry.name : entry.global,
     );
     const [first = "", ...rest] = components;
     let start: TSSymbol | undefined;
     if (isStatic && rest.length === 0) {
       // Only a member is static, and a path of one component names no member.
       start = undefined;
-    } else if (entry.shape === "module") {
+    } else if ("module" in entry) {
       const module = modules.get(entry.module);
       start = module === undefined ? undefined : memberOf(project, module, first, false);
     } else if (nameComponent(first) === first) {
@@ -329,14 +329,10 @@ export function entriesAt<Brand>(
  * program the display name the inventory gives it.
  */
 export function spelledEntry(entry: DeclarationEntry, held: Inventory): string {
-  switch (entry.shape) {
-    case "symbol":
-      return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
-    case "module":
-      return entry.name;
-    case "global":
-      return entry.global;
+  if ("symbol" in entry) {
+    return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
   }
+  return "module" in entry ? entry.name : entry.global;
 }
 
 /** One entry of a configuration key that names a declaration, and the key's dotted path. */
@@ -353,14 +349,17 @@ const LIFECYCLE_KEY = "ts.lifecycle_contracts";
  * the injection registrations, each lifecycle contract's components and then its bases,
  * and the serializers.
  */
-export function configuredDeclarations(config: Config): readonly ConfiguredDeclaration[] {
+export function configuredDeclarations(config: ResolvedConfig): readonly ConfiguredDeclaration[] {
   return [
-    ...config.ts.injectionRegistrations.map((entry) => ({
+    ...config.ts.injection_registrations.map((entry) => ({
       key: "ts.injection_registrations",
       entry,
     })),
-    ...config.ts.lifecycleContracts.flatMap((contract) =>
-      [...contract.components, ...contract.bases].map((entry) => ({ key: LIFECYCLE_KEY, entry })),
+    ...config.ts.lifecycle_contracts.flatMap((contract) =>
+      [...(contract.components ?? []), ...(contract.bases ?? [])].map((entry) => ({
+        key: LIFECYCLE_KEY,
+        entry,
+      })),
     ),
     ...config.ts.serializers.map((entry) => ({ key: "ts.serializers", entry })),
   ];
@@ -396,12 +395,8 @@ export function declarationsNamed<Brand>(
  * sign and its name, and a global entry's path after a number sign.
  */
 export function configuredRef(entry: DeclarationEntry): string {
-  switch (entry.shape) {
-    case "symbol":
-      return entry.symbol;
-    case "module":
-      return `${entry.module}#${entry.name}`;
-    case "global":
-      return `#${entry.global}`;
+  if ("symbol" in entry) {
+    return entry.symbol;
   }
+  return "module" in entry ? `${entry.module}#${entry.name}` : `#${entry.global}`;
 }