@cplieger/deadset-ts 3.1.0 → 3.3.0

package/dist/src/sweep.js

@@ -11,19 +11,16 @@ import { namesACaller, OUTSIDE } from "./graph.js";
  *
  * The order is the order the answers depend on: the callers and the marks are live
  * before either relation runs, the candidate set is every judged declaration at least
- * one relation does not hold live, and the tests of dead code join it.
+ * one relation does not hold live and no exemption holds back, and the tests of dead
+ * code join it.
  */
 export function sweep(graph, input) {
-    const marked = graph.symbols.map(() => false);
-    for (const id of input.marked) {
-        const at = graph.at(id);
-        if (at !== OUTSIDE) {
-            marked[at] = true;
-        }
-    }
-    // Every root and every mark seeds reachability. A root of a kind that names a caller,
-    // and a mark, are live under reference counting as well; a root that only supposes a
-    // caller is not.
+    const marked = flagged(graph, input.marked);
+    const exempt = flagged(graph, (input.exempt ?? []).map((record) => record.id));
+    const held = marked.map((mark, at) => mark || exempt[at] === true);
+    // Every root, every mark and every exemption seeds reachability. A root of a kind that
+    // names a caller, and a mark, are live under reference counting as well; a root that
+    // only supposes a caller is not, and neither is an exemption.
     const called = graph.symbols.map(() => false);
     for (const root of graph.rooted) {
         if (namesACaller(root.kind)) {
@@ -37,7 +34,7 @@ export function sweep(graph, input) {
         }
         return input.mode.production ? made.production : made.production + made.test;
     };
-    const reached = reachable(graph, marked, input.mode);
+    const reached = reachable(graph, held, input.mode);
     const liveUnder = graph.symbols.map((_symbol, at) => {
         const relations = [];
         if (marked[at] === true || called[at] === true || counted(at) > 0) {
@@ -48,8 +45,8 @@ export function sweep(graph, input) {
         }
         return relations;
     });
-    const dead = graph.symbols.map((_symbol, at) => graph.subject[at] === true && (liveUnder[at]?.length ?? 0) < 2);
-    const testOfDeadCode = admitTestsOfDeadCode(graph, dead, marked);
+    const dead = graph.symbols.map((_symbol, at) => graph.subject[at] === true && exempt[at] !== true && (liveUnder[at]?.length ?? 0) < 2);
+    const testOfDeadCode = admitTestsOfDeadCode(graph, dead, held);
     const candidates = [];
     const live = new Map();
     graph.symbols.forEach((symbol, at) => {
@@ -70,13 +67,25 @@ export function sweep(graph, input) {
     });
     return { liveUnder: live, candidates };
 }
+/** Per declaration of the graph, whether one of the identifiers names it. */
+function flagged(graph, ids) {
+    const flags = graph.symbols.map(() => false);
+    for (const id of ids) {
+        const at = graph.at(id);
+        if (at !== OUTSIDE) {
+            flags[at] = true;
+        }
+    }
+    return flags;
+}
 /**
  * Per declaration, whether a seed reaches it. The two seeds reach through different
- * reference sets: a marked declaration is live by a mechanism the analysis cannot see, so
- * no mode withholds a reference it makes, while a root reaches through the references the
- * mode counts. The marks run first, so what they reach is expanded under the wider rule.
+ * reference sets: a held declaration, marked or exempt, is live by a mechanism the
+ * analysis cannot see, so no mode withholds a reference it makes, a test declaration's
+ * included, while a root reaches through the references the mode counts. The held seed
+ * runs first, so what it reaches is expanded under the wider rule.
  */
-function reachable(graph, marked, mode) {
+function reachable(graph, held, mode) {
     const reached = graph.symbols.map(() => false);
     const expanded = graph.symbols.map(() => false);
     const queue = [];
@@ -98,18 +107,18 @@ function reachable(graph, marked, mode) {
             enter(exported, false);
         }
     };
-    const walk = (held) => {
+    const walk = (holding) => {
         for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
             for (const edge of graph.out[at] ?? []) {
-                if (!held && mode.production && edge.test) {
+                if (!holding && mode.production && edge.test) {
                     continue;
                 }
                 enter(edge.to, !edge.evaluation);
             }
         }
     };
-    marked.forEach((mark, at) => {
-        if (mark) {
+    held.forEach((hold, at) => {
+        if (hold) {
             enter(at, false);
         }
     });
@@ -124,12 +133,13 @@ function reachable(graph, marked, mode) {
  * Admits every test declaration whose set of referenced production declarations is
  * non-empty and wholly dead, and returns which it admitted. The set is read from every
  * reference the test makes, not the ones the mode counts: a production sweep counts none,
- * which is what makes the targets dead. A test referencing one live target is never admitted.
+ * which is what makes the targets dead. A test referencing one live target is never
+ * admitted, and neither is a marked or exempt test.
  */
-function admitTestsOfDeadCode(graph, dead, marked) {
+function admitTestsOfDeadCode(graph, dead, held) {
     const admitted = graph.symbols.map(() => false);
     graph.symbols.forEach((_symbol, at) => {
-        if (graph.test[at] !== true || graph.subject[at] !== true || marked[at] === true) {
+        if (graph.test[at] !== true || graph.subject[at] !== true || held[at] === true) {
             return;
         }
         let targets = 0;

package/dist/src/template-field.js

@@ -0,0 +1,173 @@
+/**
+ * The template-field class: a member is held back, at the lowest confidence, when a
+ * template under a configured template directory writes its name inside an action,
+ * because a template engine reads the member by that name at run time.
+ *
+ * Every file under a configured directory is a template. An action runs from an
+ * opening delimiter to the first closing one after it, at the pair
+ * `analysis.template_delimiters` sets, `{{` and `}}` by default, and each identifier
+ * it writes outside a quoted string is a name it reads: `{{ user.name }}` names `user`
+ * and `name`. A file holding an unclosed action names nothing. A name reaches the
+ * instance members of classes and the members of interfaces and object types, on any
+ * type, because nothing ties the name to a type.
+ */
+import { ConfigError } from "./config.js";
+import { memberNames } from "./member-names.js";
+import { isAbsolutePath, joinPath, normalizePath } from "./paths.js";
+/** The kinds of declaration an action can name. */
+const READ_BY_A_TEMPLATE = new Set([
+    "method",
+    "class-member",
+    "interface-method",
+    "type-member",
+]);
+/** One identifier, as the grammar of the analyzed language spells one. */
+const IDENTIFIER = /[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*/uy;
+/** Two strings ordered bytewise. */
+function compare(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    return a < b ? -1 : 1;
+}
+/**
+ * Every template under the configured directories, read once for the run, in path
+ * order and each file once. A directory is named relative to the target root, and
+ * one the target does not hold refuses the run as a usage error: the class would
+ * scan nothing, so a name that no longer matches the tree would silently switch the
+ * exemption it was configured for off. A symbolic link to a directory is not
+ * followed.
+ */
+export function readTemplates(host, targetRoot, analysis) {
+    const files = new Map();
+    const read = (dir) => {
+        const entries = [...host.readDirectory(joinPath(targetRoot, dir))].sort((a, b) => compare(a.name, b.name));
+        for (const entry of entries) {
+            const path = joinPath(dir, entry.name);
+            if (entry.directory) {
+                read(path);
+                continue;
+            }
+            const absolute = joinPath(targetRoot, path);
+            if (!files.has(path) && host.kindOf(absolute) === "file") {
+                files.set(path, host.readFile(absolute));
+            }
+        }
+    };
+    for (const configured of analysis.templateDirs) {
+        const dir = normalizePath(configured);
+        if (isAbsolutePath(dir) ||
+            dir === ".." ||
+            dir.startsWith("../") ||
+            host.kindOf(joinPath(targetRoot, dir)) !== "directory") {
+            throw new ConfigError("malformed", "analysis.template_dirs", `analysis.template_dirs: ${JSON.stringify(configured)} is not a directory below the target root`);
+        }
+        read(dir);
+    }
+    return {
+        delimiters: analysis.templateDelimiters,
+        files: [...files]
+            .map(([path, text]) => ({ path, text }))
+            .sort((a, b) => compare(a.path, b.path)),
+    };
+}
+/** The end of the quoted string that opens at `from`, past its closing quote. */
+function stringEnd(text, from) {
+    const quote = text[from];
+    let at = from + 1;
+    while (at < text.length && text[at] !== quote) {
+        at += text[at] === "\\" ? 2 : 1;
+    }
+    return at + 1;
+}
+/** The identifiers one action's inner text writes outside a quoted string, with their offsets in it. */
+function identifiersOf(inner) {
+    const found = [];
+    let at = 0;
+    while (at < inner.length) {
+        const char = inner[at] ?? "";
+        if (char === '"' || char === "'" || char === "`") {
+            at = stringEnd(inner, at);
+            continue;
+        }
+        if (/[0-9]/u.test(char)) {
+            // A number's letters are part of the number: `1e3` names nothing.
+            while (at < inner.length && /[0-9A-Za-z_.]/u.test(inner[at] ?? "")) {
+                at += 1;
+            }
+            continue;
+        }
+        IDENTIFIER.lastIndex = at;
+        const match = IDENTIFIER.exec(inner);
+        if (match !== null) {
+            found.push({ name: match[0], offset: at });
+            at += match[0].length;
+            continue;
+        }
+        at += 1;
+    }
+    return found;
+}
+/**
+ * Every identifier one template's actions write, in the order the file writes them,
+ * or none where an action is not closed.
+ */
+function namesOf(text, delimiters) {
+    const found = [];
+    let from = 0;
+    for (;;) {
+        const open = text.indexOf(delimiters.left, from);
+        if (open < 0) {
+            return found;
+        }
+        const start = open + delimiters.left.length;
+        const close = text.indexOf(delimiters.right, start);
+        if (close < 0) {
+            return [];
+        }
+        const inner = text.slice(start, close);
+        const action = `${delimiters.left}${inner.trim().replace(/\s+/gu, " ")}${delimiters.right}`;
+        for (const { name, offset } of identifiersOf(inner)) {
+            found.push({ name, offset: start + offset, action });
+        }
+        from = close + delimiters.right.length;
+    }
+}
+/** Where one offset of a template is, its column counted in UTF-16 code units. */
+function positionIn(file, offset) {
+    const before = file.text.slice(0, offset);
+    const lineStart = before.lastIndexOf("\n") + 1;
+    return {
+        path: file.path,
+        line: before.split("\n").length,
+        column: offset - lineStart + 1,
+    };
+}
+/**
+ * The template-field detector: every instance member of a class and every member of
+ * an interface or an object type whose name an action of a configured template
+ * writes, recorded at the identifier.
+ */
+export function templateField(input) {
+    const { templates } = input;
+    if (templates.files.length === 0) {
+        return [];
+    }
+    const members = memberNames(input.project.ownSourceFiles(), input.held);
+    const found = [];
+    for (const file of templates.files) {
+        for (const named of namesOf(file.text, templates.delimiters)) {
+            for (const member of members.get(named.name) ?? []) {
+                if (!READ_BY_A_TEMPLATE.has(member.kind) || member.static) {
+                    continue;
+                }
+                found.push({
+                    id: member.id,
+                    detail: `named by ${named.action}`,
+                    site: positionIn(file, named.offset),
+                });
+            }
+        }
+    }
+    return found;
+}

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "2.2.0";
+export const CONTRACT_VERSION = "3.0.0";

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -32,13 +32,13 @@
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
-    "@types/node": "24.13.5",
+    "@types/node": "24.19.0",
     "eslint": "10.11.0",
-    "fast-check": "4.10.1",
-    "prettier": "3.9.8",
+    "fast-check": "4.10.2",
+    "prettier": "3.9.9",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "typescript-eslint": "8.70.0",
-    "vitest": "5.0.1"
+    "typescript-eslint": "8.70.1",
+    "vitest": "5.0.2"
   },
   "publishConfig": {
     "access": "public"

package/src/analysis.ts

@@ -10,19 +10,32 @@
 
 import type { Diagnostic } from "@typescript/native/unstable/sync";
 import type { Config, Provenance } from "./config.ts";
+import { decorator } from "./decorator.ts";
 import { diagnosticErrors, discoverProjects, DiscoveryError } from "./discover.ts";
+import {
+  computeExemptions,
+  disabledClasses,
+  exemptionsOf,
+  retainedIn,
+  type Detector,
+  type Detectors,
+} from "./exempt.ts";
+import type { TSExemptionClass } from "./exempt-classes.ts";
 import type { Finding } from "./finding.ts";
 import type { Host } from "./host.ts";
+import { interfaceSatisfaction } from "./interface-satisfaction.ts";
 import { inventory, type Inventory } from "./inventory.ts";
 import { readManifest } from "./manifest.ts";
 import { matrixOf, sweepMatrix, type Configured, type Matrix, type SweepResult } from "./matrix.ts";
 import { relativePath, resolvePath } from "./paths.ts";
 import { byPosition, type Position } from "./position.ts";
+import { reflectiveLookup } from "./reflective-lookup.ts";
 import { references } from "./references.ts";
 import { roots, unmatchedEverywhere, unmatchedRoots, type RootKind, type Roots } from "./roots.ts";
 import type { Scope } from "./scope.ts";
 import { diagnosticsOf, runSession, type Engine, type ProjectView } from "./session.ts";
-import type { SweepInput } from "./sweep.ts";
+import type { Exemption, SweepInput } from "./sweep.ts";
+import { readTemplates, templateField } from "./template-field.ts";
 
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
@@ -196,35 +209,67 @@ export function runRoots(
 export interface RunSweep {
   readonly matrix: Matrix;
   readonly sweep: SweepResult;
+  /**
+   * The exemption records that held back a declaration some configuration of the run
+   * would otherwise judge dead, in the declarations' site order.
+   */
+  readonly retained: readonly Exemption[];
 }
 
+/** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
+const DETECTORS: Detectors = new Map<TSExemptionClass, Detector>([
+  ["interface-satisfaction", interfaceSatisfaction],
+  ["template-field", templateField],
+  ["reflective-lookup", reflectiveLookup],
+  ["decorator", decorator],
+]);
+
 /**
  * Sweeps the run the scope and the configuration describe. Each project's references
- * are read against its own inventory with the configured test-file patterns while its
- * view is open; the projects then merge into one matrix in discovery order, which is
- * swept under the input the caller decided once for the run. A project that carries
- * an error ends the run before any project is swept.
+ * and exemptions are read against its own inventory while its view is open; the
+ * projects then merge into one matrix in the run's order, which is swept under the
+ * caller's marks and mode with the exemptions every project found. A record found in
+ * one configuration holds in every configuration that holds its declaration, because
+ * an exemption is evidence of a use the analysis cannot see and a use in one
+ * configuration is a use. A project that carries an error ends the run before any
+ * project is swept.
  */
 export function runSweep(
   engine: Engine,
   host: Host,
   scope: Scope,
   config: Config,
-  input: SweepInput,
+  input: Pick<SweepInput, "marked" | "mode">,
+  detectors: Detectors = DETECTORS,
 ): RunSweep {
   const targetRoot = scope.target.path;
-  const configured = readProjects(engine, host, scope, config, (project, read): Configured => {
-    const resolved = references(project, read.held, targetRoot, {
+  const disabled = disabledClasses(config);
+  const templates = disabled.has("template-field")
+    ? { delimiters: config.analysis.templateDelimiters, files: [] }
+    : readTemplates(host, targetRoot, config.analysis);
+  const read = readProjects(engine, host, scope, config, (project, projectRead) => {
+    const resolved = references(project, projectRead.held, targetRoot, {
       testFiles: config.ts.testFiles,
     });
-    return {
-      configuration: read.configuration,
-      symbols: read.held.symbols,
+    const configured: Configured = {
+      configuration: projectRead.configuration,
+      symbols: projectRead.held.symbols,
       references: resolved.references,
-      roots: read.rooted.liveUnderReachability,
+      roots: projectRead.rooted.liveUnderReachability,
       testFiles: resolved.testFilePaths,
     };
+    const exempt = computeExemptions(
+      { project, held: projectRead.held, targetRoot, templates },
+      detectors,
+      {
+        disabled,
+        mode: input.mode,
+        testFiles: new Set(resolved.testFilePaths),
+      },
+    );
+    return { configured, exempt };
   });
-  const matrix = matrixOf(configured);
-  return { matrix, sweep: sweepMatrix(matrix, input) };
+  const matrix = matrixOf(read.map((one) => one.configured));
+  const swept: SweepInput = { ...input, exempt: exemptionsOf(read.flatMap((one) => one.exempt)) };
+  return { matrix, sweep: sweepMatrix(matrix, swept), retained: retainedIn(matrix, swept) };
 }

package/src/decorator.ts

@@ -0,0 +1,74 @@
+/**
+ * The decorator class: a member a decorator expression is attached to, and every
+ * member of a class a decorator expression is attached to, is held back, because the
+ * decorator receives the member or the class when the class is defined and may reach
+ * the member by its name.
+ *
+ * The rule is read from the tree alone: a decorator is attached where it is written.
+ * The use the decorator itself makes of what it decorates is the reference pass's,
+ * which records it as a `decorator` reference; this class records only that the
+ * declaration is held back, and the member set of a decorated class is every member
+ * the inventory holds for the class, static members included.
+ */
+
+import {
+  isCallExpression,
+  isDecorator,
+  type Decorator,
+  type Node,
+} from "@typescript/native/unstable/ast";
+import type { DetectorInput, Evidence } from "./exempt.ts";
+import { nodeKey, type InventorySymbol, type SymbolKind } from "./inventory.ts";
+import { renderPosition } from "./position.ts";
+
+/** The kinds of declaration a decorator is attached to and holds back. */
+const DECORATED: ReadonlySet<SymbolKind> = new Set(["class", "method", "class-member"]);
+
+/** How one decorator is spelled in a record: its expression, without a call's arguments. */
+function spelled(decorator: Decorator): string {
+  const expression = decorator.expression;
+  const named = isCallExpression(expression) ? expression.expression : expression;
+  return `@${named.getText().replace(/\s+/gu, "")}`;
+}
+
+/**
+ * The decorator detector: each decorated member, and each member of a decorated
+ * class, recorded at the decorator.
+ */
+export function decorator<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
+  const { project, held, targetRoot } = input;
+  const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+  const membersOf = new Map<string, InventorySymbol[]>();
+  for (const symbol of held.symbols) {
+    if (symbol.kind === "method" || symbol.kind === "class-member") {
+      const members = membersOf.get(symbol.parent);
+      if (members === undefined) {
+        membersOf.set(symbol.parent, [symbol]);
+      } else {
+        members.push(symbol);
+      }
+    }
+  }
+
+  const found: Evidence[] = [];
+  for (const file of project.ownSourceFiles()) {
+    const visit = (node: Node): void => {
+      const id = held.declarations.get(nodeKey(file, node));
+      const symbol = id === undefined ? undefined : byId.get(id);
+      if (symbol !== undefined && DECORATED.has(symbol.kind)) {
+        const modifiers = (node as { readonly modifiers?: readonly Node[] }).modifiers ?? [];
+        for (const attached of modifiers.filter(isDecorator)) {
+          const detail = `decorated by ${spelled(attached)}`;
+          const site = renderPosition(file, targetRoot, attached.getStart());
+          const reached = symbol.kind === "class" ? (membersOf.get(symbol.id) ?? []) : [symbol];
+          for (const member of reached) {
+            found.push({ id: member.id, detail, site });
+          }
+        }
+      }
+      node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+  }
+  return found;
+}

package/src/exempt-classes.ts

@@ -0,0 +1,132 @@
+/**
+ * The exemption classes of the Contract's vocabulary, in its order: each class's name,
+ * the languages it runs on, the confidence it is recorded at and, for a class that runs
+ * on TypeScript, which private members it may retain.
+ *
+ * The rows are written out rather than read from the Contract at run time, for the
+ * reason the fixed severity codes are, and a test holds them equal to the Contract
+ * release this analyzer implements. A class name is a type, so a detector table or a
+ * record naming a class the vocabulary does not hold, or one that runs on another
+ * language only, does not compile.
+ */
+
+import type { Confidence, Language } from "./config.ts";
+
+/**
+ * Whether a class may retain a member declared with the `private` modifier, and one
+ * declared with a `#private` name. The modifier is a compile-time constraint only, so
+ * such a member stays reachable by its name at run time; a private name cannot be
+ * named from outside its class body at all.
+ */
+export interface TypeScriptVisibility {
+  readonly private: boolean;
+  readonly privateName: boolean;
+}
+
+/** One class of the vocabulary. */
+interface ExemptionClassRow {
+  readonly class: string;
+  readonly languages: readonly Language[];
+  readonly confidence: Confidence;
+  /** Present exactly on a class that runs on TypeScript. */
+  readonly typescriptVisibility?: TypeScriptVisibility;
+}
+
+/** Every class of the vocabulary, in the order the Contract lists them. */
+export const EXEMPTION_CLASSES = [
+  {
+    class: "interface-satisfaction",
+    languages: ["go", "ts"],
+    confidence: "certain",
+    typescriptVisibility: { private: false, privateName: false },
+  },
+  { class: "encoding-reflection", languages: ["go"], confidence: "certain" },
+  { class: "format-verb-contract", languages: ["go"], confidence: "certain" },
+  { class: "errors-duck-typing", languages: ["go"], confidence: "certain" },
+  {
+    class: "enum-group",
+    languages: ["go", "ts"],
+    confidence: "certain",
+    typescriptVisibility: { private: false, privateName: false },
+  },
+  { class: "generated-file", languages: ["go"], confidence: "certain" },
+  { class: "linkname-cgo-asm-plugin", languages: ["go"], confidence: "certain" },
+  {
+    class: "template-field",
+    languages: ["go", "ts"],
+    confidence: "possible",
+    typescriptVisibility: { private: true, privateName: false },
+  },
+  {
+    class: "reflective-lookup",
+    languages: ["go", "ts"],
+    confidence: "possible",
+    typescriptVisibility: { private: true, privateName: false },
+  },
+  {
+    class: "decorator",
+    languages: ["ts"],
+    confidence: "certain",
+    typescriptVisibility: { private: true, privateName: false },
+  },
+  {
+    class: "injection-container",
+    languages: ["ts"],
+    confidence: "certain",
+    typescriptVisibility: { private: true, privateName: false },
+  },
+  {
+    class: "framework-lifecycle",
+    languages: ["ts"],
+    confidence: "certain",
+    typescriptVisibility: { private: true, privateName: false },
+  },
+  {
+    class: "serialization-contract",
+    languages: ["ts"],
+    confidence: "certain",
+    typescriptVisibility: { private: true, privateName: false },
+  },
+] as const satisfies readonly ExemptionClassRow[];
+
+type Row = (typeof EXEMPTION_CLASSES)[number];
+
+/** The name of a class of the vocabulary. */
+export type ExemptionClass = Row["class"];
+
+/** The classes of the rows that list one language. */
+type ClassesOf<R, L extends Language> = R extends {
+  readonly class: infer C;
+  readonly languages: readonly (infer Listed)[];
+}
+  ? L extends Listed
+    ? C
+    : never
+  : never;
+
+/** The name of a class that runs on TypeScript, the only classes this analyzer records. */
+export type TSExemptionClass = ClassesOf<Row, "ts">;
+
+function runsOnTS(row: Row): row is Extract<Row, { readonly class: TSExemptionClass }> {
+  const languages: readonly Language[] = row.languages;
+  return languages.includes("ts");
+}
+
+const TS_ROWS = EXEMPTION_CLASSES.filter(runsOnTS);
+
+/** The classes that run on TypeScript, in the vocabulary's order. */
+export const TS_EXEMPTION_CLASSES: readonly TSExemptionClass[] = TS_ROWS.map((row) => row.class);
+
+const VISIBILITY: ReadonlyMap<TSExemptionClass, TypeScriptVisibility> = new Map(
+  TS_ROWS.map((row) => [row.class, row.typescriptVisibility]),
+);
+
+/** Which private members one class that runs on TypeScript may retain. */
+export function typescriptVisibilityOf(exemptionClass: TSExemptionClass): TypeScriptVisibility {
+  return VISIBILITY.get(exemptionClass) ?? { private: false, privateName: false };
+}
+
+/** Whether one name is a class of the vocabulary, whichever language it runs on. */
+export function isExemptionClass(name: string): name is ExemptionClass {
+  return EXEMPTION_CLASSES.some((row) => row.class === name);
+}