@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.2

package/src/mdx-entries.ts

@@ -0,0 +1,241 @@
+/**
+ * The files the import declarations of the target's Markdown and MDX documents load. A
+ * document is read as text: a line outside a fenced code block that starts with `import`
+ * is an import declaration, which an MDX compiler hoists into the module it builds.
+ */
+
+import type { SourceFile } from "@typescript/native/ast";
+import { resolveRelativeSpecifier } from "./configuration-files.ts";
+import type { Host } from "./host.ts";
+import { dirnamePath, joinPath, resolvePath } from "./paths.ts";
+import type { SourceFiles } from "./source-files.ts";
+
+/** One file a document imports, the specifier that named it, and the export names it reads. */
+interface DocumentEntry {
+  readonly file: SourceFile;
+  readonly source: string;
+  /** The export names the import reads, or undefined for a namespace import, which reads them all. */
+  readonly names: readonly string[] | undefined;
+}
+
+/** The directories no document is read below. */
+const SKIPPED: ReadonlySet<string> = new Set(["node_modules", ".git"]);
+
+/** The extensions of a document whose imports an MDX compiler reads. */
+const DOCUMENT = /\.mdx?$/u;
+
+/** A fence line, its marker run and what follows it captured. */
+const FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/u;
+
+/** A string literal in either quote, its escapes included. */
+const STRING = String.raw`"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'`;
+
+/** An import declaration at the start of a line, its clause and its specifier captured. */
+const IMPORT_LINE = new RegExp(
+  String.raw`^import\s+(?:((?:[^"'\n]|${STRING})*?)\s+from\s*)?["']([^"'\n]+)["']`,
+  "u",
+);
+
+/** The braces of an import clause, what they hold captured. */
+const BRACES = new RegExp(String.raw`\{((?:[^}"']|${STRING})*)\}`, "u");
+
+/** One comma-separated part of a clause's braces. */
+const PART = new RegExp(String.raw`(?:[^,"']|${STRING})+`, "gu");
+
+/** A named import of a clause's braces: the exported name and an optional local alias. */
+const NAMED_IMPORT = new RegExp(String.raw`^([\w$]+|${STRING})(?:\s+as\s+[\w$]+)?$`, "u");
+
+/** The single-character escapes of a string literal and the character each stands for. */
+const SINGLE_ESCAPES: ReadonlyMap<string, string> = new Map([
+  ["b", "\b"],
+  ["f", "\f"],
+  ["n", "\n"],
+  ["r", "\r"],
+  ["t", "\t"],
+  ["v", "\v"],
+  ["0", "\0"],
+  ["'", "'"],
+  ['"', '"'],
+  ["\\", "\\"],
+]);
+
+/**
+ * One escape of a string literal: two hexadecimal digits, a code unit, a code point, or one
+ * character and the digit after it.
+ */
+const ESCAPE = /\\(?:x([\da-fA-F]{2})|u([\da-fA-F]{4})|u\{([\da-fA-F]+)\}|(.)(\d?))/gu;
+
+/** What one escape stands for, or undefined for one a module cannot hold. */
+function unescaped([, hex, unit, point, single, digit]: RegExpExecArray): string | undefined {
+  if (single === undefined) {
+    const code = Number.parseInt(hex ?? unit ?? point ?? "", 16);
+    return code <= 0x10ffff ? String.fromCodePoint(code) : undefined;
+  }
+  return /[1-9xu]/u.test(single) || (single === "0" && digit !== "")
+    ? undefined
+    : `${SINGLE_ESCAPES.get(single) ?? single}${digit ?? ""}`;
+}
+
+/**
+ * The value of a quoted export name, its escapes decoded, or undefined for an escape this
+ * reading does not decode. A module is strict code, so no legacy octal escape is valid.
+ */
+function quotedName(literal: string): string | undefined {
+  const body = literal.slice(1, -1);
+  let value = "";
+  let from = 0;
+  for (const escape of body.matchAll(ESCAPE)) {
+    const decoded = unescaped(escape);
+    if (decoded === undefined) {
+      return undefined;
+    }
+    value += body.slice(from, escape.index) + decoded;
+    from = escape.index + escape[0].length;
+  }
+  return value + body.slice(from);
+}
+
+/**
+ * The export names one import clause reads: `default` for a default binding and each name
+ * its braces list, or undefined for a namespace import, which reads every export, and for
+ * a clause this reading does not parse, which may read any.
+ */
+function clauseNames(clause: string): readonly string[] | undefined {
+  const braces = BRACES.exec(clause);
+  const head = (braces === null ? clause : clause.slice(0, braces.index))
+    .replace(/,\s*$/u, "")
+    .trim();
+  if (head.includes("*")) {
+    return undefined;
+  }
+  const names = head === "" ? [] : ["default"];
+  if (head !== "" && !/^[\w$]+$/u.test(head)) {
+    return undefined;
+  }
+  for (const part of (braces?.[1]?.match(PART) ?? []).map((one) => one.trim())) {
+    const named = NAMED_IMPORT.exec(part);
+    if (part === "") {
+      continue;
+    }
+    if (named?.[1] === undefined) {
+      return undefined;
+    }
+    const name = /^["']/u.test(named[1]) ? quotedName(named[1]) : named[1];
+    if (name === undefined) {
+      return undefined;
+    }
+    names.push(name);
+  }
+  return names;
+}
+
+/** Every document below `dir`, outside every skipped directory, by absolute path. */
+function documents(host: Host, dir: string): readonly string[] {
+  let entries;
+  try {
+    entries = host.readDirectory(dir);
+  } catch {
+    return [];
+  }
+  const found: string[] = [];
+  for (const entry of entries) {
+    const path = joinPath(dir, entry.name);
+    if (entry.directory) {
+      if (!SKIPPED.has(entry.name)) {
+        found.push(...documents(host, path));
+      }
+    } else if (DOCUMENT.test(entry.name)) {
+      found.push(path);
+    }
+  }
+  return found.sort();
+}
+
+/** The relative specifiers one document's import lines name, its fenced code blocks skipped. */
+function importedBy(
+  text: string,
+): readonly { readonly specifier: string; readonly names: readonly string[] | undefined }[] {
+  const found: { specifier: string; names: readonly string[] | undefined }[] = [];
+  let open: string | undefined;
+  for (const line of text.split(/\r?\n/u)) {
+    const fence = FENCE.exec(line);
+    const marker = fence?.[1];
+    if (marker !== undefined && open === undefined) {
+      open = marker;
+      continue;
+    }
+    // https://spec.commonmark.org/0.31.2/#fenced-code-blocks: only a run of the opening
+    // character, at least as long and followed by nothing, closes a fence.
+    if (
+      marker !== undefined &&
+      open !== undefined &&
+      marker.startsWith(open.slice(0, 1)) &&
+      marker.length >= open.length &&
+      fence?.[2]?.trim() === ""
+    ) {
+      open = undefined;
+      continue;
+    }
+    const matched = open === undefined ? IMPORT_LINE.exec(line) : null;
+    const specifier = matched?.[2];
+    if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+      found.push({ specifier, names: clauseNames(matched?.[1] ?? "") });
+    }
+  }
+  return found;
+}
+
+/** One document below a target root, by absolute path, and what its import lines name. */
+interface DocumentImports {
+  readonly path: string;
+  readonly imports: ReturnType<typeof importedBy>;
+}
+
+/**
+ * The documents each host's target roots hold, which every project of a run reads alike,
+ * kept for the host's life as {@link Host} allows.
+ */
+const documentsOf = new WeakMap<Host, Map<string, readonly DocumentImports[]>>();
+
+/** Every readable document below `root` and the import lines it writes, read once per host. */
+function documentImports(host: Host, root: string): readonly DocumentImports[] {
+  const byRoot = documentsOf.get(host) ?? new Map<string, readonly DocumentImports[]>();
+  documentsOf.set(host, byRoot);
+  const known = byRoot.get(root);
+  if (known !== undefined) {
+    return known;
+  }
+  const found = documents(host, root).flatMap((path) => {
+    try {
+      return [{ path, imports: importedBy(host.readFile(path)) }];
+    } catch {
+      return [];
+    }
+  });
+  byRoot.set(root, found);
+  return found;
+}
+
+/**
+ * Every own file one document below the target root imports by a relative specifier,
+ * read against the document's directory, on disk or through the emit mapping.
+ */
+export function documentEntries(
+  host: Host,
+  targetRoot: string,
+  files: SourceFiles,
+): readonly DocumentEntry[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  const found: DocumentEntry[] = [];
+  for (const { path, imports } of documentImports(host, root)) {
+    const dir = dirnamePath(path);
+    for (const { specifier, names } of imports) {
+      const reached = resolveRelativeSpecifier(host, dir, specifier);
+      const held = reached === undefined ? undefined : files.byName.get(reached);
+      for (const file of held === undefined ? files.named(resolvePath(dir, specifier)) : [held]) {
+        found.push({ file, source: specifier, names });
+      }
+    }
+  }
+  return found;
+}

package/src/module-declarations.ts

@@ -104,6 +104,8 @@ function namesModule(specifier: string, name: string): boolean {
 interface Named {
   readonly id: string;
   readonly members: readonly string[];
+  /** Whether the declaration's name is a pattern, which a specifier names by matching it. */
+  readonly wildcard: boolean;
 }
 
 /**
@@ -140,7 +142,7 @@ function namedBy(
         ]),
       );
       const members = (children.get(id) ?? []).filter((child) => wanted.has(child.ref));
-      return [{ id, members: members.map((child) => child.id) }];
+      return [{ id, members: members.map((child) => child.id), wildcard: name.includes("*") }];
     });
 }
 
@@ -208,28 +210,24 @@ export function moduleDeclarationReferences<Brand>(
   imports.forEach((one, index) => {
     const resolved = moduleOf(declared.length + index);
     const position = renderPosition(one.file, root, one.specifier.getStart());
-    const read = (to: string, resolution: Reference["resolution"]): void => {
-      found.push({
-        from: one.from,
-        to,
-        position,
-        use: "read",
-        resolution,
-        test: testFiles.has(position.path),
-      });
+    const read = (to: string, resolution: Reference["resolution"], test: boolean): void => {
+      found.push({ from: one.from, to, position, use: "read", resolution, test });
     };
+    const test = testFiles.has(position.path);
     const same = new Set(
       declared
         .filter((_, at) => resolved !== undefined && resolved === moduleOf(at))
         .map((declaration) => declaration.id),
     );
     for (const id of same) {
-      read(id, "batch");
+      read(id, "batch", test);
     }
     for (const declaration of named(one.specifier.text, one.names)) {
-      if (!same.has(declaration.id)) {
+      // A wildcard declaration is how the compiler types the file a matching specifier
+      // names, so the import uses it whoever writes it, a test included.
+      if (declaration.wildcard || !same.has(declaration.id)) {
         for (const to of [declaration.id, ...declaration.members]) {
-          read(to, "syntax");
+          read(to, "syntax", test && !declaration.wildcard);
         }
       }
     }

package/src/overrides.ts

@@ -1,10 +1,9 @@
 /**
- * The overrides of the target's class members. A call through the base class names the
- * base's member and runs the override of whichever subclass the value is, so the base
- * member's declaration references every override. A method, an accessor or a property,
- * static or not, overriding a member of a class declared outside the target, at any depth
- * of its `extends` chain, is used by outside code holding the instance or the class
- * through that class, so its own class references it.
+ * The overrides of the target's class members. A call through the base class runs the
+ * override of whichever subclass the value is, so the base member references every
+ * override. A member, static or not, overriding one of a class declared outside the target
+ * at any depth of its `extends` chain, a library's interface-and-variable class such as
+ * `Error` included, is used by outside code holding the value, so its own class references it.
  */
 
 import {
@@ -115,12 +114,16 @@ export function overrideReferences<Brand>(
       if (
         inTarget.length === 0 &&
         declared !== UNANSWERED &&
-        (declared.flags & SymbolFlags.Class) !== 0 &&
-        // The target's augmentation of an outside class merges an interface into it,
-        // so only a class declaration says where the class is.
-        declared.declarations.some(
-          (handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path),
-        )
+        (((declared.flags & SymbolFlags.Class) !== 0 &&
+          // The target's augmentation of an outside class merges an interface into it,
+          // so only a class declaration says where the class is.
+          declared.declarations.some(
+            (handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path),
+          )) ||
+          ((declared.flags & SymbolFlags.Interface) !== 0 &&
+            declared.declarations.some(
+              (handle) => handle.kind === SyntaxKind.VariableDeclaration && !own.has(handle.path),
+            )))
       ) {
         outsideBases.set(id, declared);
       }
@@ -185,11 +188,13 @@ function outsideMemberNames<Brand>(
   outsideBases: ReadonlyMap<string, TSSymbol>,
 ): ReadonlyMap<string, ReadonlySet<string>> {
   const direct = new Map<string, ReadonlySet<string>>();
+  const error = errorType(project);
   for (const [classId, base] of outsideBases) {
     const instance = project.queries.declaredTypeOf(base);
     const statics = project.queries.typeOfSymbol(base);
     const components = [
       ...namesOf(project, instance === UNANSWERED ? undefined : instance).map(nameComponent),
+      ...(instance !== UNANSWERED && reaches(project, instance, error) ? ["toString"] : []),
       ...namesOf(project, statics === UNANSWERED ? undefined : statics).map(
         (name) => `${nameComponent(name)}:static`,
       ),
@@ -218,6 +223,40 @@ function outsideMemberNames<Brand>(
   return names;
 }
 
+/** The global `Error` instance type's identifier, where the program's library declares one. */
+function errorType<Brand>(project: ProjectView<Brand>): number | undefined {
+  const symbol = project.queries.resolveName("Error", SymbolFlags.Type, undefined, false);
+  if (symbol === UNANSWERED || symbol === undefined) {
+    return undefined;
+  }
+  const type = project.queries.declaredTypeOf(symbol);
+  return type === UNANSWERED ? undefined : type.id;
+}
+
+/**
+ * Whether one type is the `Error` instance type or extends it at any depth: the runtime
+ * prints an error through its `toString`, a member the library's `Error` interface omits.
+ */
+function reaches<Brand>(
+  project: ProjectView<Brand>,
+  type: Type,
+  target: number | undefined,
+): boolean {
+  const seen = new Set<number>();
+  const pending = [type];
+  for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+    if (next.id === target) {
+      return true;
+    }
+    if (!seen.has(next.id)) {
+      seen.add(next.id);
+      const bases = project.queries.baseTypes(next);
+      pending.push(...(bases === UNANSWERED ? [] : bases));
+    }
+  }
+  return false;
+}
+
 /** The names of a type's properties; none where the type or its properties are unanswered. */
 function namesOf<Brand>(project: ProjectView<Brand>, type: Type | undefined): readonly string[] {
   const properties = type === undefined ? UNANSWERED : project.queries.propertiesOf(type);

package/src/print.ts

@@ -84,6 +84,7 @@ export function printConfig(config: Config, provenance: Provenance): string {
         members: entry.members,
       })),
       serializers: config.ts.serializers.map(declarationOf),
+      roots_complete: config.ts.rootsComplete,
     },
     provenance: Object.fromEntries(
       [...provenance]

package/src/ref.ts

@@ -49,9 +49,11 @@ export const REF_EXPRESSIONS: readonly string[] = [
   `^${SCOPE}#$`,
   `^${SCOPE}#${TS_HEAD}$`,
   `^${SCOPE}#(?:${TS_QUOTED}\\.)?${TS_HEAD}:alias$`,
+  `^${SCOPE}#${TS_HEAD}:import$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+:static$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?<${TS_IDENT}>$`,
+  `^${SCOPE}#(?:${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?)?\\(${TS_IDENT}\\)$`,
   `^${MANIFEST_SCOPE}#${TS_PACKAGE}:(?:dependency|dev-dependency|peer-dependency)$`,
 ];
 
@@ -151,6 +153,16 @@ export function computedComponent(text: string): string {
   return `[${text.replaceAll(ASCII_WHITESPACE, "")}]`;
 }
 
+/** The reference of an import binding, read against the reference of the module that holds it. */
+export function importRef(moduleRef: string, name: string): string {
+  return `${moduleRef}${nameComponent(name)}:import`;
+}
+
+/** The reference of a parameter, read against the reference of the declaration that holds it. */
+export function parameterRef(holderRef: string, name: string): string {
+  return `${holderRef}(${name})`;
+}
+
 /** The fragment of an export alias, inside the `declare module` block named, if one is. */
 export function aliasFragment(name: string, block?: string): string {
   const head = block === undefined ? "" : `${quoted(block)}.`;

package/src/references.ts

@@ -15,7 +15,10 @@ import {
   isIdentifier,
   isImportDeclaration,
   isImportEqualsDeclaration,
+  isInterfaceDeclaration,
   isMetaProperty,
+  isModuleBlock,
+  isModuleDeclaration,
   isNewExpression,
   isNamespaceExport,
   isNoSubstitutionTemplateLiteral,
@@ -49,7 +52,7 @@ import {
   type Inventory,
   type InventorySymbol,
 } from "./inventory.ts";
-import { augmentationReferences } from "./augmentations.ts";
+import { ambientGlobalInterfaces, augmentationReferences } from "./augmentations.ts";
 import { elementAccessReferences } from "./element-access.ts";
 import { indexedAccessReferences } from "./indexed-access.ts";
 import { keyofComparisonReferences } from "./keyof-comparisons.ts";
@@ -60,8 +63,15 @@ import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./pat
 import { byPosition, isComponentFile, renderPosition, type Position } from "./position.ts";
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
+import { typeParameterReads } from "./type-parameter-reads.ts";
 import { typeQueryAliases } from "./type-query-alias.ts";
-import { computedKeyNames, keyNameOf, keyedUses, type KeyedAccess } from "./symbol-keys.ts";
+import {
+  computedKeyNames,
+  iterationReferences,
+  keyNameOf,
+  keyedUses,
+  type KeyedAccess,
+} from "./symbol-keys.ts";
 import { handedOn, valuesOf } from "./value-flow.ts";
 
 /**
@@ -1603,6 +1613,39 @@ export function references<Brand>(
     }
   }
 
+  /** The ambient global interfaces of the walked files that merge into a declaration outside the project's own files. */
+  const libraryMerged = (scripts: ReadonlySet<string>): ReadonlySet<string> => {
+    const names = new Map<string, Node>();
+    const visit = (node: Node): void => {
+      if (isInterfaceDeclaration(node)) {
+        const id = declaredAt(node);
+        if (id !== undefined) {
+          names.set(id, node.name);
+        }
+      } else if (isModuleDeclaration(node) || isModuleBlock(node)) {
+        node.forEachChild(visit);
+      }
+    };
+    for (const { file } of walked) {
+      file.forEachChild(visit);
+    }
+    const global = new Set(ambientGlobalInterfaces(held, [...names.keys()], scripts));
+    const asked = [...names].filter(([id]) => global.has(id));
+    if (asked.length === 0) {
+      return new Set();
+    }
+    const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
+    return new Set(
+      asked.flatMap(([id], at) => {
+        const symbol = answers[at];
+        return typeof symbol === "object" &&
+          symbol.declarations.some((handle) => !ownPaths.has(handle.path))
+          ? [id]
+          : [];
+      }),
+    );
+  };
+
   const usesOf = new Map(walked.map((one) => [one.file, one.uses]));
   for (const [file, writes] of valued) {
     const uses = usesOf.get(file) ?? [];
@@ -1621,6 +1664,8 @@ export function references<Brand>(
     found.push(...indexedAccessReferences(project, held, chains, root, new Set(tests)));
     found.push(...elementAccessReferences(project, held, chains, root, new Set(tests)));
     found.push(...keyofComparisonReferences(project, held, chains, root, new Set(tests)));
+    found.push(...iterationReferences(project, held, chains, root, new Set(tests)));
+    found.push(...typeParameterReads(project, held, chains, root, new Set(tests)));
     found.push(...unimplementedCalleeReads(project, held, chains, root, new Set(tests)));
     found.push(...moduleDeclarationReferences(project, held, root, new Set(tests)));
     typedLookups = (options.requestCount?.() ?? 0) - before;
@@ -1628,7 +1673,7 @@ export function references<Brand>(
   const scripts = new Set(
     walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId),
   );
-  found.push(...augmentationReferences(held, found, scripts));
+  found.push(...augmentationReferences(held, found, scripts, libraryMerged(scripts)));
   found.sort(
     (a, b) =>
       byPosition(a.position, b.position) ||

package/src/report.ts

@@ -19,7 +19,7 @@ import type { StaleSuppression } from "./findings/self-check.ts";
 import type { TestFileRule } from "./references.ts";
 
 /** The version of the report schema this analyzer writes a report to. */
-const SCHEMA_VERSION = "8.2.0";
+const SCHEMA_VERSION = "9.0.0";
 
 /** Every report schema version this analyzer reads: the one the Contract it implements admits. */
 export const SCHEMA_VERSIONS_ACCEPTED: readonly string[] = [SCHEMA_VERSION];
@@ -224,12 +224,21 @@ export interface Report {
   readonly excluded_by_cgo: readonly never[];
   readonly test_file_rules: readonly TestFileRule[];
   readonly type_error_skips: readonly TypeErrorSkip[];
-  readonly notes: readonly never[];
+  readonly notes: readonly ReportNote[];
   readonly unanswered_questions: readonly UnansweredCount[];
   readonly conventions_applied: readonly AppliedConvention[];
   readonly totals: WireTotals;
 }
 
+/** One hint about the run's setup, as the report schema's `notes` spells it. */
+export interface ReportNote {
+  readonly kind: "unmapped-entry";
+  /** The directory of the manifest the note is about, below the target root. */
+  readonly path: string;
+  readonly key: "ts.entry_files";
+  readonly message: string;
+}
+
 /** What one run answered, from which its report is built. */
 export interface ReportInput {
   readonly contractVersion: string;
@@ -247,6 +256,8 @@ export interface ReportInput {
   readonly unanswered: readonly UnansweredCount[];
   /** The convention rows the run applied, in the report's order. */
   readonly conventionsApplied: readonly AppliedConvention[];
+  /** The notes the run states, in any order. */
+  readonly notes?: readonly ReportNote[];
 }
 
 /** Two strings ordered bytewise. */
@@ -510,7 +521,9 @@ export function buildReport(input: ReportInput): Report {
     ]
       .sort(([a, x], [b, y]) => compare(x.path, y.path) || x.line - y.line || compare(a, b))
       .map(([, skip]) => skip),
-    notes: [],
+    notes: [...new Map((input.notes ?? []).map((one) => [JSON.stringify(one), one])).entries()]
+      .sort(([a, x], [b, y]) => compare(x.kind, y.kind) || compare(x.path, y.path) || compare(a, b))
+      .map(([, note]) => note),
     unanswered_questions: [...input.unanswered]
       .sort(
         (a, b) =>

package/src/resolve.ts

@@ -112,6 +112,7 @@ interface Doc {
   readonly injectionRegistrations: readonly DeclarationEntry[] | undefined;
   readonly lifecycleContracts: readonly LifecycleContract[] | undefined;
   readonly serializers: readonly DeclarationEntry[] | undefined;
+  readonly rootsComplete: boolean | undefined;
 }
 
 /** One document the resolution reads, with the origin its settings carry. */
@@ -894,6 +895,7 @@ function readDoc(value: unknown, label: string): Doc {
     ),
     lifecycleContracts: readLifecycleContracts(ts, label),
     serializers: readDeclarations(ts, "serializers", "ts.serializers", label),
+    rootsComplete: readBoolean(ts, "roots_complete", "ts.roots_complete", label),
   };
 }
 
@@ -1191,6 +1193,7 @@ function settleAll(inputs: Inputs): { config: Config; provenance: Map<string, Or
         (doc) => doc.lifecycleContracts,
       ),
       serializers: at("ts.serializers", defaults.ts.serializers, (doc) => doc.serializers),
+      rootsComplete: at("ts.roots_complete", defaults.ts.rootsComplete, (doc) => doc.rootsComplete),
     },
   };