@cplieger/deadset-ts 3.3.1 → 3.5.0

package/README.md

@@ -8,7 +8,7 @@ deadset-ts is a command-line analyzer for TypeScript and JavaScript projects. It
 
 deadset-ts is report-only. It never edits source, and it refuses any `--fix` flag.
 
-**Status: pre-release.** This version implements contract 3.0.0 and ships the analyzer's foundation: one compiler session per run over the projects `analysis.configurations` declares, in the order it lists them, each a compiler configuration file below the target, or, where it declares none, every `tsconfig` project discovered under the target (the explicit scope, every `tsconfig*.json`, each project's `references`), a fail-closed read of every project's diagnostics, configuration decoding against the contract's closed key list with `print-config` and its provenance, `print-projects`, the report-only guard, the symbol inventory of every declaration a project's own files hold down to its class and type members, the one-pass reference resolution over that inventory, which resolves each file's identifiers in batches ([batch-cap calibration](docs/batch-cap-calibration.md) is the measurement behind the batch size), and the root set `print-roots` prints. A root is a declaration the analysis keeps live without a reference: what a file exports when the manifest names it through `main`, `module`, `types`, `bin` or `exports`, or when `ts.entry_files` matches it; a library target's published API; the configuration, setup and test files of Vitest, Stryker and Playwright, the flat configuration of ESLint, and a worker or service worker a call addresses by a string literal; and every declaration a `roots.patterns` entry names. An entry that names nothing is reported as `DS1704` and fails the run. The entry-point conventions of other tools are not read, and `DECLINED_CONVENTIONS` lists each one with the reason. Four exemption classes hold a declaration back from the sweep, and `print-retained` lists what each one held back: `interface-satisfaction`, a member an interface requires of a class whose value reaches that interface; `decorator`, a decorated member and every member of a decorated class; and, at the lowest confidence, `template-field`, a member an action of a template under `analysis.template_dirs` names, and `reflective-lookup`, a member a literal key of an element access or of `Reflect.get`, `Reflect.set` or `Reflect.has` names. None of them holds back a `#private` member. The analysis is reached through the command, and through `run()` for a caller that runs the command in-process; no other verb reports findings yet, so `analyze`, `explain` and `describe` exit with a usage message. The one runtime dependency is the `typescript` package at exactly 7.0.2, installed under the `@typescript/native` name until TypeScript 7.1 ships a compiler API the tooling can share.
+**Status: pre-release.** This version implements contract 3.2.0 and ships the analyzer's foundation: one compiler session per run over the projects `analysis.configurations` declares, in the order it lists them, each a compiler configuration file below the target, or, where it declares none, every `tsconfig` project discovered under the target (the explicit scope, every `tsconfig*.json`, each project's `references`), a fail-closed read of every project's diagnostics, configuration decoding against the contract's closed key list with `print-config` and its provenance, `print-projects`, the report-only guard, the symbol inventory of every declaration a project's own files hold down to its class and type members, the one-pass reference resolution over that inventory, which resolves each file's identifiers in batches ([batch-cap calibration](docs/batch-cap-calibration.md) is the measurement behind the batch size), and the root set `print-roots` prints. A root is a declaration the analysis keeps live without a reference: what a file exports when the manifest names it through `main`, `module`, `types`, `bin` or `exports`, or when `ts.entry_files` matches it; a library target's published API; the configuration, setup and test files of Vitest, Stryker and Playwright, the flat configuration of ESLint, and a worker or service worker a call addresses by a string literal; and every declaration a `roots.patterns` entry names. An entry that names nothing is reported as `DS1704` and fails the run. The entry-point conventions of other tools are not read, and `DECLINED_CONVENTIONS` lists each one with the reason. Seven exemption classes hold a declaration back from the sweep, and `print-retained` lists what each one held back: `interface-satisfaction`, a member an interface requires of a class whose value reaches that interface; `decorator`, a decorated member and every member of a decorated class; `injection-container`, a decorated property of a class a dependency-injection container constructs, being a class passed to a call `ts.injection_registrations` names or one a parameter of whose constructor carries a decorator; `framework-lifecycle`, a member a `ts.lifecycle_contracts` entry lists, on a class that is the entry's component by a decorator or a call the entry names or by extending a class it names; `serialization-contract`, the properties of a class whose values reach `JSON.stringify` or a declaration `ts.serializers` names, and those and its `toJSON` and `toString` where a value is passed to an `unknown` or `any` parameter of a function outside the analysis; and, at the lowest confidence, `template-field`, a member an action of a template under `analysis.template_dirs` names, and `reflective-lookup`, a member a literal key of an element access or of `Reflect.get`, `Reflect.set` or `Reflect.has` names. None of them holds back a `#private` member. The analysis is reached through the command, and through `run()` for a caller that runs the command in-process; no other verb reports findings yet, so `analyze`, `explain` and `describe` exit with a usage message. The one runtime dependency is the `typescript` package at exactly 7.0.2, installed under the `@typescript/native` name until TypeScript 7.1 ships a compiler API the tooling can share.
 
 ## Install
 

package/dist/src/analysis.js

@@ -10,6 +10,8 @@
 import { decorator } from "./decorator.js";
 import { diagnosticErrors, discoverProjects, DiscoveryError } from "./discover.js";
 import { computeExemptions, disabledClasses, exemptionsOf, retainedIn, } from "./exempt.js";
+import { frameworkLifecycle } from "./framework-lifecycle.js";
+import { injectionContainer } from "./injection-container.js";
 import { interfaceSatisfaction } from "./interface-satisfaction.js";
 import { inventory } from "./inventory.js";
 import { readManifest } from "./manifest.js";
@@ -19,6 +21,7 @@ import { byPosition } from "./position.js";
 import { reflectiveLookup } from "./reflective-lookup.js";
 import { references } from "./references.js";
 import { roots, unmatchedEverywhere, unmatchedRoots } from "./roots.js";
+import { serializationContract } from "./serialization-contract.js";
 import { diagnosticsOf, runSession } from "./session.js";
 import { readTemplates, templateField } from "./template-field.js";
 /** The setting whose source decides where a finding about a configured root sits. */
@@ -128,6 +131,9 @@ const DETECTORS = new Map([
     ["template-field", templateField],
     ["reflective-lookup", reflectiveLookup],
     ["decorator", decorator],
+    ["injection-container", injectionContainer],
+    ["framework-lifecycle", frameworkLifecycle],
+    ["serialization-contract", serializationContract],
 ]);
 /**
  * Sweeps the run the scope and the configuration describe. Each project's references
@@ -145,6 +151,7 @@ export function runSweep(engine, host, scope, config, input, detectors = DETECTO
     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,
@@ -156,7 +163,7 @@ export function runSweep(engine, host, scope, config, input, detectors = DETECTO
             roots: projectRead.rooted.liveUnderReachability,
             testFiles: resolved.testFilePaths,
         };
-        const exempt = computeExemptions({ project, held: projectRead.held, targetRoot, templates }, detectors, {
+        const exempt = computeExemptions({ project, held: projectRead.held, targetRoot, templates, ts: config.ts, consumers }, detectors, {
             disabled,
             mode: input.mode,
             testFiles: new Set(resolved.testFilePaths),

package/dist/src/calls.js

@@ -0,0 +1,154 @@
+/**
+ * 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, } from "@typescript/native/unstable/ast";
+import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { nodeKey } from "./inventory.js";
+import { DEFAULT_BATCH_CAP } from "./references.js";
+/** The name node a callee or a decorator expression resolves through, where it has one. */
+export function calleeName(expression) {
+    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) {
+    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) {
+    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) {
+    return (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(project, nodes) {
+    const followed = new Map();
+    const targets = new Map();
+    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 = 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, found) {
+    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) {
+    const found = [];
+    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(project, held, chains, calls) {
+    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) => {
+        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 }))),
+    ]));
+}
+/** Every class declaration of the target that carries a decorator. */
+export function decoratedClasses(project, held) {
+    const found = [];
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node) => {
+            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(project) {
+    const found = [];
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node) => {
+            if (isCallExpression(node)) {
+                found.push(node);
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    return found;
+}

package/dist/src/class-members.js

@@ -0,0 +1,92 @@
+/**
+ * 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 } from "@typescript/native/unstable/ast";
+import { nodeKey } from "./inventory.js";
+import { DEFAULT_BATCH_CAP } from "./references.js";
+/** The name node of each class declaration of the target, by the class's identifier. */
+export function classNames(project, held) {
+    const names = new Map();
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node) => {
+            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(project, nodes) {
+    const types = [];
+    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(project, nodes, side) {
+    if (side === "instance") {
+        return typesAt(project, nodes);
+    }
+    const symbols = project.symbolsAt(nodes.map((node) => project.handle(node)));
+    const present = symbols.filter((symbol) => 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(project, held, classIds, side) {
+    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();
+    named.forEach(([id], index) => {
+        const type = types[index];
+        if (type === undefined) {
+            return;
+        }
+        const found = [];
+        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, byId) {
+    const parent = byId.get(symbol.parent);
+    if (parent === undefined || !symbol.ref.startsWith(`${parent.ref}.`)) {
+        return undefined;
+    }
+    return symbol.ref.slice(parent.ref.length + 1);
+}

package/dist/src/components.js

@@ -1,7 +1,7 @@
 /**
- * The dead components of one graph: the strongly connected components of the subgraph
- * the dead declarations induce, ordered so a report is worked from the top down, each
- * with the root members a deletion starts at and what falls with it.
+ * The dead components of one graph. A component is a set of dead declarations one
+ * deletion removes together: its root members, which are where the deletion starts,
+ * and every dead declaration that falls with them, being dead only through them.
  */
 import { OUTSIDE } from "./graph.js";
 /** The name every component identifier this analyzer mints starts with. */
@@ -10,21 +10,21 @@ const ANALYZER = "deadset-ts";
 const ID_DIGITS = 4;
 /** The index of a declaration the component walk has not reached. */
 const UNVISITED = -1;
-/** What a report carries for one component: its roots and what falls, and its members in full. */
+/** What a report carries for one component: its roots and counts, and its members in full. */
 export function listing(component, cascade) {
     return {
         roots: component.roots,
         members: cascade === "full" ? component.members : [],
-        symbolCount: component.falls.length,
+        symbolCount: component.members.length,
         deletableLines: component.deletableLines,
     };
 }
 /**
- * Groups the declarations `dead` marks into components and orders them so each precedes
- * every component it reaches, two that neither reaches ordered by their first member's
- * site. `dead` and `testOfDeadCode` hold one flag per declaration of the graph; the dead
- * set arrives rather than being read from a sweep, so a set several sweeps intersect is
- * grouped over this graph's edges the same way.
+ * Groups the declarations `dead` marks into components, ordered by their first member's
+ * site; `dead` and `testOfDeadCode` hold one flag per declaration of the graph. Root
+ * members sit on the cycles no other cycle references. A cycle two roots both reach is
+ * dead only through both, so a component is a weakly connected part of the dead
+ * subgraph: no dead declaration of one references a declaration of another.
  */
 export function componentsOf(graph, dead, testOfDeadCode) {
     const { at, adjacent } = deadSubgraph(graph, dead, testOfDeadCode);
@@ -32,25 +32,21 @@ export function componentsOf(graph, dead, testOfDeadCode) {
         return [];
     }
     const { componentOf, members } = connected(adjacent);
-    const { edges, into } = condense(adjacent, componentOf, members.length);
-    const falls = fallSets(edges, members, into);
-    const outsideReference = externallyReferenced(adjacent, componentOf);
+    const referenced = referencedCycles(adjacent, componentOf, members.length);
+    const groups = joined(adjacent);
     const idOf = (position) => graph.symbols[at[position] ?? 0]?.id ?? "";
-    return order(edges, members).map((group, place) => {
-        const own = members[group] ?? [];
-        const roots = own.filter((position) => {
-            // A dead member of a dead container is never a root: the container is where the
-            // deletion starts and the member falls with it.
+    return groups.map((group, place) => {
+        const roots = group.filter((position) => {
+            // A dead member's dead container is on the member's own cycle, and the container
+            // is where the deletion starts.
             const container = graph.parent[at[position] ?? 0] ?? OUTSIDE;
-            return outsideReference[position] !== true && dead[container] !== true;
+            return referenced[componentOf[position] ?? 0] !== true && dead[container] !== true;
         });
-        const fallen = falls[group] ?? [];
         return {
             id: `${ANALYZER}/c-${String(place + 1).padStart(ID_DIGITS, "0")}`,
-            members: own.map(idOf),
+            members: group.map(idOf),
             roots: roots.map(idOf),
-            falls: fallen.map(idOf),
-            deletableLines: linesSpanned(fallen.map((position) => graph.symbols[at[position] ?? 0])),
+            deletableLines: linesSpanned(group.map((position) => graph.symbols[at[position] ?? 0])),
         };
     });
 }
@@ -127,10 +123,9 @@ function deadSubgraph(graph, dead, testOfDeadCode) {
     return { at, adjacent };
 }
 /**
- * Each declaration's component and each component's members by site, by Tarjan's
+ * Each declaration's cycle and each cycle's members by site, by Tarjan's
  * algorithm in one pass. The walk keeps its own stack of frames, so a chain of any length
- * is walked without growing the call stack. Components are closed in an order in which
- * each follows every component it reaches.
+ * is walked without growing the call stack.
  */
 function connected(adjacent) {
     const index = adjacent.map(() => UNVISITED);
@@ -193,97 +188,57 @@ function connected(adjacent) {
     });
     return { componentOf, members };
 }
-/**
- * Per component, the components it reaches in one step, and how many components reach
- * it, each pair counted once. An edge inside a component is not an edge between two, so
- * the result is acyclic.
- */
-function condense(adjacent, componentOf, count) {
-    const edges = Array.from({ length: count }, () => []);
-    const into = Array.from({ length: count }, () => 0);
-    const seen = new Set();
+/** Per cycle, whether a dead declaration outside it references one of its members. */
+function referencedCycles(adjacent, componentOf, count) {
+    const referenced = Array.from({ length: count }, () => false);
     adjacent.forEach((targets, from) => {
         for (const to of targets) {
-            const a = componentOf[from] ?? 0;
-            const b = componentOf[to] ?? 0;
-            const pair = `${String(a)}>${String(b)}`;
-            if (a === b || seen.has(pair)) {
-                continue;
-            }
-            seen.add(pair);
-            edges[a]?.push(b);
-            into[b] = (into[b] ?? 0) + 1;
-        }
-    });
-    return { edges, into };
-}
-/** Per dead declaration, whether a dead component other than its own references it. */
-function externallyReferenced(adjacent, componentOf) {
-    const referenced = adjacent.map(() => false);
-    adjacent.forEach((targets, from) => {
-        for (const to of targets) {
-            if (componentOf[from] !== componentOf[to]) {
-                referenced[to] = true;
+            const cycle = componentOf[to] ?? 0;
+            if (componentOf[from] !== cycle) {
+                referenced[cycle] = true;
             }
         }
     });
     return referenced;
 }
 /**
- * The components in the order a report is worked in. Tarjan closes each component after
- * every one it reaches, so reading the closing order backwards is a topological order,
- * and one pass over it gives each component its depth below the roots.
+ * The weakly connected parts of the dead subgraph, each its positions in ascending
+ * order, ordered by their first position. Positions follow the graph's declaration
+ * order, so a part's first position is its first member's site.
  */
-function order(edges, members) {
-    const sequence = edges.map((_targets, component) => component).reverse();
-    const depth = edges.map(() => 0);
-    for (const from of sequence) {
-        for (const to of edges[from] ?? []) {
-            depth[to] = Math.max(depth[to] ?? 0, (depth[from] ?? 0) + 1);
-        }
-    }
-    return sequence.sort((a, b) => (depth[a] ?? 0) - (depth[b] ?? 0) || (members[a]?.[0] ?? 0) - (members[b]?.[0] ?? 0));
-}
-/**
- * Per component, the dead declarations one deletion of it removes. A root of the
- * condensation carries its members and every component only it reaches; any other
- * component carries its own members alone, because what it reaches is reached through a
- * root above it as well.
- */
-function fallSets(edges, members, into) {
-    // Each root's walk stamps what it reaches with the root's own number, so the walks
-    // share one array rather than allocating one per root.
-    const stamp = edges.map(() => UNVISITED);
-    const reach = new Map();
-    const owners = edges.map(() => 0);
-    edges.forEach((_targets, root) => {
-        if (into[root] !== 0) {
-            return;
-        }
-        const reached = [root];
-        stamp[root] = root;
-        // An array's iterator reads its length at every step, so what a step pushes is
-        // walked in the same loop.
-        for (const at of reached) {
-            for (const to of edges[at] ?? []) {
-                if (stamp[to] !== root) {
-                    stamp[to] = root;
-                    reached.push(to);
-                }
-            }
-        }
-        reach.set(root, reached);
-        for (const component of reached) {
-            owners[component] = (owners[component] ?? 0) + 1;
+function joined(adjacent) {
+    const leader = adjacent.map((_edges, position) => position);
+    const find = (position) => {
+        let top = position;
+        while ((leader[top] ?? top) !== top) {
+            top = leader[top] ?? top;
+        }
+        // Every position on the walk points at the top afterwards, so a later find is short.
+        for (let step = position; step !== top;) {
+            const next = leader[step] ?? top;
+            leader[step] = top;
+            step = next;
+        }
+        return top;
+    };
+    adjacent.forEach((targets, from) => {
+        for (const to of targets) {
+            const a = find(from);
+            const b = find(to);
+            // The smaller position leads, so a part's leader is its first position.
+            leader[Math.max(a, b)] = Math.min(a, b);
         }
     });
-    return members.map((own, component) => {
-        const set = [...own];
-        for (const other of reach.get(component) ?? []) {
-            if (other !== component && owners[other] === 1) {
-                set.push(...(members[other] ?? []));
-            }
+    const parts = new Map();
+    adjacent.forEach((_edges, position) => {
+        const top = find(position);
+        const part = parts.get(top);
+        if (part === undefined) {
+            parts.set(top, [position]);
+        }
+        else {
+            part.push(position);
         }
-        return set.sort((a, b) => a - b);
     });
+    return [...parts.values()];
 }

package/dist/src/config.js

@@ -34,9 +34,18 @@ export function defaultConfig() {
             maxFindings: 0,
             failOn: "deny",
         },
+        providers: {
+            analyzers: [
+                { shape: "installed", name: "deadset-go", languages: ["go"], command: "deadset-go" },
+                { shape: "installed", name: "deadset-ts", languages: ["ts"], command: "deadset-ts" },
+            ],
+        },
         ts: {
             testFiles: ["**/*.test.{ts,tsx,mts,cts}"],
             entryFiles: [],
+            injectionRegistrations: [],
+            lifecycleContracts: [],
+            serializers: [],
         },
     };
 }