@cplieger/deadset-ts 3.3.0 → 3.4.0

package/dist/src/value-reach.js

@@ -0,0 +1,120 @@
+/**
+ * The classes of the target a value of one type carries, as a serializer walking the
+ * value reaches them: through union and intersection constituents, array and tuple
+ * elements, and the data members of the target's classes and of object types the
+ * target writes. The walk stops at `any`, `unknown`, a type parameter, a function and
+ * an interface or class of another program, so an instance held only there is missed.
+ */
+import { ObjectFlags, SymbolFlags, } from "@typescript/native/unstable/sync";
+import { classNames, typesAt } from "./class-members.js";
+/** The object types whose members the walk reads whatever declares them. */
+const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped;
+/** The symbols of an anonymous object type the target writes as a type. */
+const LITERAL_SYMBOLS = SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral;
+/** The global array types, whose element type is what an array value carries. */
+function arrayTargets(project) {
+    const checker = project.checker;
+    return new Set(["Array", "ReadonlyArray"].flatMap((name) => {
+        const symbol = checker.resolveName(name, SymbolFlags.Type, undefined, false);
+        return symbol === undefined ? [] : [checker.getDeclaredTypeOfSymbol(symbol).id];
+    }));
+}
+/**
+ * The walk over one project's types, against the classes of `held`, the same
+ * project's inventory.
+ */
+export function valueReach(project, held) {
+    const checker = project.checker;
+    const names = [...classNames(project, held)];
+    const declared = typesAt(project, names.map(([, node]) => node));
+    const classOfTarget = new Map();
+    names.forEach(([id], index) => {
+        const type = declared[index];
+        if (type !== undefined) {
+            classOfTarget.set(type.id, id);
+        }
+    });
+    const arrays = arrayTargets(project);
+    const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const children = new Map();
+    /** The generic target of a type reference, and the type itself otherwise. */
+    const targetOf = (type) => (type.objectFlags & ObjectFlags.Reference) !== 0 && type.isTypeReference()
+        ? type.getTarget()
+        : type;
+    const classOf = (type) => {
+        if (!type.isObjectType()) {
+            return undefined;
+        }
+        return classOfTarget.get(type.id) ?? classOfTarget.get(targetOf(type).id);
+    };
+    /** Whether the target writes the object type, so its members are what the value holds. */
+    const isWritten = (type) => {
+        if ((type.objectFlags & WRITTEN) !== 0) {
+            return true;
+        }
+        const symbol = type.getSymbol();
+        if (symbol === undefined) {
+            return false;
+        }
+        if ((type.objectFlags & ObjectFlags.Anonymous) !== 0) {
+            return (symbol.flags & LITERAL_SYMBOLS) !== 0;
+        }
+        return ((symbol.flags & SymbolFlags.Interface) !== 0 &&
+            symbol.declarations.every((handle) => own.has(handle.path)));
+    };
+    /** The types a value of one object type holds in its data members. */
+    const memberTypes = (type) => {
+        const properties = checker
+            .getPropertiesOfType(type)
+            .filter((property) => (property.flags & SymbolFlags.Property) !== 0);
+        const types = properties.length === 0 ? [] : checker.getTypeOfSymbol(properties);
+        return [
+            ...types.filter((held) => held !== undefined),
+            ...checker.getIndexInfosOfType(type).map((info) => info.valueType),
+        ];
+    };
+    /** The types a value of one type holds, read once per type. */
+    const childrenOf = (type) => {
+        const known = children.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        let found = [];
+        if (type.isUnionType() || type.isIntersectionType()) {
+            found = type.getTypes();
+        }
+        else if (type.isObjectType()) {
+            const target = targetOf(type);
+            const isList = type.isTypeReference() &&
+                (arrays.has(target.id) ||
+                    (target.isObjectType() && (target.objectFlags & ObjectFlags.Tuple) !== 0));
+            if (classOf(type) !== undefined || (!isList && isWritten(type))) {
+                found = memberTypes(type);
+            }
+            else if (isList && type.isTypeReference()) {
+                found = checker.getTypeArguments(type);
+            }
+        }
+        children.set(type.id, found);
+        return found;
+    };
+    return {
+        classesOf: (type) => {
+            const found = new Set();
+            const seen = new Set();
+            const pending = [type];
+            for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+                if (seen.has(next.id)) {
+                    continue;
+                }
+                seen.add(next.id);
+                const owner = classOf(next);
+                if (owner !== undefined) {
+                    found.add(owner);
+                }
+                pending.push(...childrenOf(next));
+            }
+            return found;
+        },
+    };
+}

package/dist/src/verbs/print-config.js

@@ -0,0 +1,9 @@
+import { printConfig } from "../print.js";
+import { resolve } from "../resolve.js";
+import { EXIT_CLEAN } from "./verb.js";
+/** Writes the resolved configuration with the source of every setting. */
+export const printConfigVerb = ({ out, inputs }) => {
+    const { config, provenance } = resolve(inputs());
+    out.write(printConfig(config, provenance));
+    return EXIT_CLEAN;
+};

package/dist/src/verbs/print-projects.js

@@ -0,0 +1,34 @@
+import { diagnosticErrors, discoverProjects, renderDiagnostic } from "../discover.js";
+import { resolveMatrix } from "../resolve.js";
+import { diagnosticsOf, runSession } from "../session.js";
+import { EXIT_CLEAN, EXIT_FAILURE } from "./verb.js";
+/**
+ * Writes the name of every project one run analyzes, one per line, having read each
+ * project's diagnostics first: the identifier the build matrix declares for it, or,
+ * where discovery derived the project, its configuration file's path below the
+ * target root.
+ */
+export const printProjectsVerb = ({ out, err, host, inputs, scope, openClient }) => {
+    const matrix = resolveMatrix(inputs());
+    const scoped = scope();
+    const engine = openClient(false);
+    const discovered = discoverProjects(engine, host, scoped, matrix);
+    const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
+    const failures = [];
+    const { projects } = runSession(engine, discovered.configFiles, (project) => {
+        const errors = diagnosticErrors(diagnosticsOf(project));
+        failures.push(...errors.map(renderDiagnostic));
+        return ids.get(project.configFile) ?? project.configFile;
+    });
+    if (failures.length > 0) {
+        for (const line of failures) {
+            err.write(`${line}\n`);
+        }
+        err.write(`deadset-ts: ${String(failures.length)} error(s); no answer was produced\n`);
+        return EXIT_FAILURE;
+    }
+    for (const id of projects) {
+        out.write(`${id}\n`);
+    }
+    return EXIT_CLEAN;
+};

package/dist/src/verbs/print-retained.js

@@ -0,0 +1,23 @@
+import { runSweep } from "../analysis.js";
+import { retainedLines } from "../exempt.js";
+import { resolve } from "../resolve.js";
+import { EXIT_CLEAN } from "./verb.js";
+/**
+ * Writes every declaration an exemption held back in the production sweep a report is
+ * built from, one per line, and nothing where no exemption held one back. One fact
+ * several configurations found is one record, so the line names no configuration. The
+ * line shape is this command's own rather than a Contract format, so that sort and cut
+ * read it.
+ */
+export const printRetainedVerb = ({ out, host, inputs, scope, openClient }) => {
+    const { config } = resolve(inputs());
+    const scoped = scope();
+    const swept = runSweep(openClient(false), host, scoped, config, {
+        marked: [],
+        mode: { production: true },
+    });
+    for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
+        out.write(`${line}\n`);
+    }
+    return EXIT_CLEAN;
+};

package/dist/src/verbs/print-roots.js

@@ -0,0 +1,36 @@
+import { runRoots } from "../analysis.js";
+import { resolve } from "../resolve.js";
+import { EXIT_CLEAN, EXIT_FINDINGS } from "./verb.js";
+/**
+ * One root as a line: the declaration's reference, why it is a root, and the string
+ * that named it, separated by tabs. A run of several configurations adds the ones
+ * whose project holds the root as a fourth field, and writes the third present and
+ * empty where no string named the root, so every line of one run holds the same
+ * fields.
+ */
+function rootLine(root, several) {
+    const line = `${root.ref}\t${root.kind}`;
+    if (several) {
+        return `${line}\t${root.source}\t${root.configurations.join(" ")}`;
+    }
+    return root.source === "" ? line : `${line}\t${root.source}`;
+}
+/**
+ * Writes the root set of the run, one root per line, and then names on the error
+ * stream, by its issue kind, every configured root or pattern that named nothing;
+ * one such string fails the run. The line shape is this command's own rather than a
+ * Contract format, so that sort and cut read it.
+ */
+export const printRootsVerb = ({ out, err, host, inputs, scope, openClient }) => {
+    const { config, provenance } = resolve(inputs());
+    const scoped = scope();
+    const answer = runRoots(openClient(false), host, scoped, config, provenance);
+    const several = answer.configurations.length > 1;
+    for (const root of answer.roots) {
+        out.write(`${rootLine(root, several)}\n`);
+    }
+    for (const finding of answer.findings) {
+        err.write(`${finding.code}: roots.patterns names nothing: ${finding.symbol.ref}\n`);
+    }
+    return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;
+};

package/dist/src/verbs/verb.js

@@ -0,0 +1,5 @@
+/** The exit codes the Contract's exit-code table names. */
+export const EXIT_CLEAN = 0;
+export const EXIT_FINDINGS = 1;
+export const EXIT_USAGE = 2;
+export const EXIT_FAILURE = 3;

package/dist/src/verbs/version.js

@@ -0,0 +1,7 @@
+import { CONTRACT_VERSION } from "../version.js";
+import { EXIT_CLEAN } from "./verb.js";
+/** Writes the version the host reports and the Contract version this analyzer implements. */
+export const versionVerb = ({ out, host }) => {
+    out.write(`deadset-ts ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
+    return EXIT_CLEAN;
+};

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 = "3.0.0";
+export const CONTRACT_VERSION = "3.1.0";

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -37,7 +37,7 @@
     "fast-check": "4.10.2",
     "prettier": "3.9.9",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "typescript-eslint": "8.70.1",
+    "typescript-eslint": "8.71.0",
     "vitest": "5.0.2"
   },
   "publishConfig": {

package/src/analysis.ts

@@ -22,7 +22,9 @@ import {
 } from "./exempt.ts";
 import type { TSExemptionClass } from "./exempt-classes.ts";
 import type { Finding } from "./finding.ts";
+import { frameworkLifecycle } from "./framework-lifecycle.ts";
 import type { Host } from "./host.ts";
+import { injectionContainer } from "./injection-container.ts";
 import { interfaceSatisfaction } from "./interface-satisfaction.ts";
 import { inventory, type Inventory } from "./inventory.ts";
 import { readManifest } from "./manifest.ts";
@@ -33,6 +35,7 @@ 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 { serializationContract } from "./serialization-contract.ts";
 import { diagnosticsOf, runSession, type Engine, type ProjectView } from "./session.ts";
 import type { Exemption, SweepInput } from "./sweep.ts";
 import { readTemplates, templateField } from "./template-field.ts";
@@ -222,6 +225,9 @@ const DETECTORS: Detectors = new Map<TSExemptionClass, Detector>([
   ["template-field", templateField],
   ["reflective-lookup", reflectiveLookup],
   ["decorator", decorator],
+  ["injection-container", injectionContainer],
+  ["framework-lifecycle", frameworkLifecycle],
+  ["serialization-contract", serializationContract],
 ]);
 
 /**
@@ -247,6 +253,7 @@ export function runSweep(
   const templates = disabled.has("template-field")
     ? { delimiters: config.analysis.templateDelimiters, files: [] }
     : readTemplates(host, targetRoot, config.analysis);
+  const consumers = scope.consumers.map((consumer) => consumer.path);
   const read = readProjects(engine, host, scope, config, (project, projectRead) => {
     const resolved = references(project, projectRead.held, targetRoot, {
       testFiles: config.ts.testFiles,
@@ -259,7 +266,7 @@ export function runSweep(
       testFiles: resolved.testFilePaths,
     };
     const exempt = computeExemptions(
-      { project, held: projectRead.held, targetRoot, templates },
+      { project, held: projectRead.held, targetRoot, templates, ts: config.ts, consumers },
       detectors,
       {
         disabled,

package/src/calls.ts

@@ -0,0 +1,224 @@
+/**
+ * The calls and decorators of one project that the configured classes read: what each
+ * callee resolves to, and which of the target's classes a call passes or a decorator
+ * is attached to. A class is passed as an argument, or as an element of an array
+ * literal or a property value of an object literal written as one, at any depth, and a
+ * decorator written as a call is a call.
+ */
+
+import {
+  isArrayLiteralExpression,
+  isCallExpression,
+  isClassDeclaration,
+  isDecorator,
+  isIdentifier,
+  isObjectLiteralExpression,
+  isParenthesizedExpression,
+  isPropertyAccessExpression,
+  isPropertyAssignment,
+  isShorthandPropertyAssignment,
+  isSpreadElement,
+  type CallExpression,
+  type Decorator,
+  type Expression,
+  type Node,
+} from "@typescript/native/unstable/ast";
+import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/unstable/sync";
+import type { AliasChains } from "./alias-chain.ts";
+import { nodeKey, type Inventory } from "./inventory.ts";
+import { DEFAULT_BATCH_CAP } from "./references.ts";
+import type { ProjectView } from "./session.ts";
+
+/** One value written where a call passes it, and the node its declaration is resolved from. */
+export interface PassedValue {
+  /** Where the value is written, which is where a record of it sits. */
+  readonly site: Node;
+  /** The name the value is resolved through, or the shorthand assignment that holds it. */
+  readonly name: Node;
+  readonly shorthand: boolean;
+}
+
+/** One class of the target a call passes or a decorator is attached to, and where. */
+export interface ClassUse {
+  /** The inventory's identifier of the class. */
+  readonly id: string;
+  readonly site: Node;
+}
+
+/** The name node a callee or a decorator expression resolves through, where it has one. */
+export function calleeName(expression: Expression): Node | undefined {
+  if (isParenthesizedExpression(expression)) {
+    return calleeName(expression.expression);
+  }
+  if (isPropertyAccessExpression(expression)) {
+    return expression.name;
+  }
+  return isIdentifier(expression) ? expression : undefined;
+}
+
+/** The callee one decorator names: its expression, or the callee of the call it writes. */
+export function decoratorCallee(decorator: Decorator): Node | undefined {
+  const expression = decorator.expression;
+  return calleeName(isCallExpression(expression) ? expression.expression : expression);
+}
+
+/** How one decorator is spelled in a record: its expression, without a call's arguments. */
+export function spelledDecorator(decorator: Decorator): string {
+  const expression = decorator.expression;
+  const named = isCallExpression(expression) ? expression.expression : expression;
+  return `@${named.getText().replace(/\s+/gu, "")}`;
+}
+
+/** The decorators written on one declaration. */
+export function decoratorsOf(node: Node): readonly Decorator[] {
+  return ((node as { readonly modifiers?: readonly Node[] }).modifiers ?? []).filter(isDecorator);
+}
+
+/**
+ * What each of a batch of nodes resolves to, every alias followed to the declaration
+ * it stands for. A node the checker resolves to nothing, and an alias that resolves
+ * to nothing, are absent from the answer. Each alias is followed once.
+ */
+export function resolvedTargets<Brand>(
+  project: ProjectView<Brand>,
+  nodes: readonly Node[],
+): ReadonlyMap<Node, TSSymbol> {
+  const followed = new Map<number, TSSymbol | undefined>();
+  const targets = new Map<Node, TSSymbol>();
+  for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
+    const run = nodes.slice(from, from + DEFAULT_BATCH_CAP);
+    project.symbolsAt(run.map((node) => project.handle(node))).forEach((symbol, index) => {
+      const node = run[index];
+      if (symbol === undefined || node === undefined) {
+        return;
+      }
+      let target: TSSymbol | undefined = symbol;
+      if ((symbol.flags & SymbolFlags.Alias) !== 0) {
+        if (!followed.has(symbol.id)) {
+          const aliased = project.checker.getAliasedSymbol(symbol);
+          followed.set(symbol.id, aliased.declarations.length === 0 ? undefined : aliased);
+        }
+        target = followed.get(symbol.id);
+      }
+      if (target !== undefined) {
+        targets.set(node, target);
+      }
+    });
+  }
+  return targets;
+}
+
+/** The values one expression passes: itself, or what an array or object literal holds. */
+function passedIn(expression: Expression, found: PassedValue[]): void {
+  if (isParenthesizedExpression(expression)) {
+    passedIn(expression.expression, found);
+    return;
+  }
+  if (isArrayLiteralExpression(expression)) {
+    for (const element of expression.elements) {
+      passedIn(isSpreadElement(element) ? element.expression : element, found);
+    }
+    return;
+  }
+  if (isObjectLiteralExpression(expression)) {
+    for (const property of expression.properties) {
+      if (isPropertyAssignment(property)) {
+        passedIn(property.initializer, found);
+      } else if (isShorthandPropertyAssignment(property)) {
+        found.push({ site: property.name, name: property, shorthand: true });
+      }
+    }
+    return;
+  }
+  const name = calleeName(expression);
+  if (name !== undefined) {
+    found.push({ site: expression, name, shorthand: false });
+  }
+}
+
+/** The values one argument passes, a spread argument's included. */
+export function valuesPassed(argument: Expression): readonly PassedValue[] {
+  const found: PassedValue[] = [];
+  passedIn(isSpreadElement(argument) ? argument.expression : argument, found);
+  return found;
+}
+
+/**
+ * The classes of the target each call passes, by the call. A value that names no
+ * class of the target, a class of another program included, passes nothing here.
+ */
+export function classesPassed<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  chains: AliasChains,
+  calls: readonly CallExpression[],
+): ReadonlyMap<CallExpression, readonly ClassUse[]> {
+  const passed = new Map(
+    calls.map((call) => [call, call.arguments.flatMap((argument) => valuesPassed(argument))]),
+  );
+  const all = [...passed.values()].flat();
+  const targets = resolvedTargets(
+    project,
+    all.filter((value) => !value.shorthand).map((value) => value.name),
+  );
+  const classes = new Set(
+    held.symbols.filter((symbol) => symbol.kind === "class").map((symbol) => symbol.id),
+  );
+  const classesOf = (value: PassedValue): readonly string[] => {
+    const symbol = value.shorthand
+      ? project.shorthandValueAt(project.handle(value.name))
+      : targets.get(value.name);
+    return symbol === undefined
+      ? []
+      : chains.declarationsOf(symbol).filter((id) => classes.has(id));
+  };
+  return new Map(
+    [...passed].map(([call, values]) => [
+      call,
+      values.flatMap((value) => classesOf(value).map((id) => ({ id, site: value.site }))),
+    ]),
+  );
+}
+
+/** One class declaration of the target and the decorators written on it. */
+export interface DecoratedClass {
+  readonly id: string;
+  readonly decorators: readonly Decorator[];
+}
+
+/** Every class declaration of the target that carries a decorator. */
+export function decoratedClasses<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+): readonly DecoratedClass[] {
+  const found: DecoratedClass[] = [];
+  for (const file of project.ownSourceFiles()) {
+    const visit = (node: Node): void => {
+      if (isClassDeclaration(node)) {
+        const id = held.declarations.get(nodeKey(file, node));
+        const decorators = decoratorsOf(node);
+        if (id !== undefined && decorators.length > 0) {
+          found.push({ id, decorators });
+        }
+      }
+      node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+  }
+  return found;
+}
+
+/** Every call expression of the project's own files, decorators written as calls included. */
+export function callsOf<Brand>(project: ProjectView<Brand>): readonly CallExpression[] {
+  const found: CallExpression[] = [];
+  for (const file of project.ownSourceFiles()) {
+    const visit = (node: Node): void => {
+      if (isCallExpression(node)) {
+        found.push(node);
+      }
+      node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+  }
+  return found;
+}

package/src/class-members.ts

@@ -0,0 +1,136 @@
+/**
+ * The members a value of one of the target's classes carries, as the checker answers
+ * for the class's type, so a member a base class declares is a member of every class
+ * that extends it and a member a subclass overrides is the subclass's own.
+ */
+
+import { isClassDeclaration, isClassExpression, type Node } from "@typescript/native/unstable/ast";
+import type { Symbol as TSSymbol, SymbolFlags, Type } from "@typescript/native/unstable/sync";
+import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
+import { DEFAULT_BATCH_CAP } from "./references.ts";
+import type { ProjectView } from "./session.ts";
+
+/** One member of a class's value that the target declares. */
+export interface ClassMember {
+  /** The inventory's identifier of the declaration. */
+  readonly id: string;
+  /** The declaring node, whose syntax says whether it is a property, an accessor or a method. */
+  readonly node: Node;
+  /** The member's symbol flags, as the checker reads it on this class. */
+  readonly flags: SymbolFlags;
+}
+
+/** Which side of a class a reading asks for: its instances, or the class itself. */
+export type ClassSide = "instance" | "static";
+
+/** The name node of each class declaration of the target, by the class's identifier. */
+export function classNames<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+): ReadonlyMap<string, Node> {
+  const names = new Map<string, Node>();
+  for (const file of project.ownSourceFiles()) {
+    const visit = (node: Node): void => {
+      if ((isClassDeclaration(node) || isClassExpression(node)) && node.name !== undefined) {
+        const id = held.declarations.get(nodeKey(file, node));
+        if (id !== undefined) {
+          names.set(id, node.name);
+        }
+      }
+      node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+  }
+  return names;
+}
+
+/** The types of a batch of nodes, asked in capped batches. */
+export function typesAt<Brand>(
+  project: ProjectView<Brand>,
+  nodes: readonly Node[],
+): (Type | undefined)[] {
+  const types: (Type | undefined)[] = [];
+  for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
+    types.push(...project.checker.getTypeAtLocation(nodes.slice(from, from + DEFAULT_BATCH_CAP)));
+  }
+  return types;
+}
+
+/**
+ * The type one side of each class is: the instance type at the class's name, or the
+ * type of the class's own symbol, which is its constructor's.
+ */
+function sideTypes<Brand>(
+  project: ProjectView<Brand>,
+  nodes: readonly Node[],
+  side: ClassSide,
+): (Type | undefined)[] {
+  if (side === "instance") {
+    return typesAt(project, nodes);
+  }
+  const symbols = project.symbolsAt(nodes.map((node) => project.handle(node)));
+  const present = symbols.filter((symbol): symbol is TSSymbol => symbol !== undefined);
+  const types = present.length === 0 ? [] : project.checker.getTypeOfSymbol(present);
+  let next = 0;
+  return symbols.map((symbol) => (symbol === undefined ? undefined : types[next++]));
+}
+
+/**
+ * The members one side of each class carries that the target declares, by the class.
+ * A member declared in a file outside the project's own, and the `prototype` a class
+ * carries on its static side, are not declarations of the target and are left out.
+ */
+export function classMembers<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  classIds: ReadonlySet<string>,
+  side: ClassSide,
+): ReadonlyMap<string, readonly ClassMember[]> {
+  const named = [...classNames(project, held)].filter(([id]) => classIds.has(id));
+  const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+  const types = sideTypes(
+    project,
+    named.map(([, node]) => node),
+    side,
+  );
+  const members = new Map<string, readonly ClassMember[]>();
+  named.forEach(([id], index) => {
+    const type = types[index];
+    if (type === undefined) {
+      return;
+    }
+    const found: ClassMember[] = [];
+    for (const property of project.checker.getPropertiesOfType(type)) {
+      for (const handle of property.declarations) {
+        if (!own.has(handle.path)) {
+          continue;
+        }
+        const node = project.declarationAt(handle)?.node;
+        const declared =
+          node === undefined
+            ? undefined
+            : held.declarations.get(nodeKey(node.getSourceFile(), node));
+        if (node !== undefined && declared !== undefined) {
+          found.push({ id: declared, node, flags: property.flags });
+        }
+      }
+    }
+    members.set(id, found);
+  });
+  return members;
+}
+
+/**
+ * The last component of one member's stable reference, `:static` included, which is
+ * how a configuration names a member; undefined for a declaration that is no member.
+ */
+export function memberComponent(
+  symbol: InventorySymbol,
+  byId: ReadonlyMap<string, InventorySymbol>,
+): string | undefined {
+  const parent = byId.get(symbol.parent);
+  if (parent === undefined || !symbol.ref.startsWith(`${parent.ref}.`)) {
+    return undefined;
+  }
+  return symbol.ref.slice(parent.ref.length + 1);
+}