@cplieger/deadset-ts 3.4.0 → 3.5.0

package/dist/src/scope.js

@@ -1,4 +1,6 @@
+import { ConfigError } from "./config.js";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.js";
+import { checkDocument } from "./schema.js";
 /** The roles a scope document declares for a module. */
 export const ROLE_TARGET = "target";
 export const ROLE_CONSUMER = "consumer";
@@ -17,18 +19,37 @@ export class ScopeError extends Error {
         this.name = "ScopeError";
     }
 }
-const DECLARED_KEYS = new Set(["target", "workspace", "consumers"]);
-const MODULE_KEYS = new Set(["id", "role", "path"]);
+const MODULE = {
+    kind: "section",
+    members: { id: { kind: "leaf" }, role: { kind: "leaf" }, path: { kind: "leaf" } },
+};
+/** The closed key list of the scope document, compared as bytes. */
+const SCOPE_ROOT = {
+    kind: "section",
+    members: {
+        target: MODULE,
+        workspace: { kind: "leaf" },
+        consumers: { kind: "list", members: MODULE.members ?? {} },
+    },
+};
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/**
+ * One string member, or undefined where the document omits it. A member the
+ * document writes is a string holding at least one character, so `null` and `""`
+ * are refused rather than read as absent.
+ */
 function stringMember(parent, name, at) {
     if (!Object.hasOwn(parent, name)) {
-        return "";
+        return undefined;
     }
     const value = parent[name];
     if (typeof value !== "string") {
-        throw new ScopeError(`scope: ${at}.${name} is not a string`);
+        throw new ScopeError(`scope: ${at === "" ? name : `${at}.${name}`} is not a string`);
+    }
+    if (value === "") {
+        throw new ScopeError(`scope: ${at === "" ? name : `${at}.${name}`} names nothing`);
     }
     return value;
 }
@@ -36,30 +57,46 @@ function readModule(value, at, role, documentDir) {
     if (!isRecord(value)) {
         throw new ScopeError(`scope: ${at} is not an object`);
     }
-    for (const name of Object.keys(value)) {
-        if (!MODULE_KEYS.has(name)) {
-            throw new ScopeError(`scope: ${at}.${name} is not a declared key`);
-        }
-    }
     const declared = stringMember(value, "role", at);
-    if (declared !== "" && declared !== role) {
+    if (declared !== undefined && declared !== role) {
         throw new ScopeError(`scope: ${at}.role is ${JSON.stringify(declared)}, want ${JSON.stringify(role)}`);
     }
     const path = stringMember(value, "path", at);
-    if (path === "") {
+    if (path === undefined) {
         throw new ScopeError(`scope: ${at}.path names nothing`);
     }
     return {
-        id: stringMember(value, "id", at),
+        id: stringMember(value, "id", at) ?? "",
         path: isAbsolutePath(path) ? path : joinPath(documentDir, path),
     };
 }
 /**
- * Decodes the scope document at `file`. Decoding is strict: an undeclared key is an
- * error, and a relative path inside the document resolves against the document's
- * own directory.
+ * Walks the document's text against the closed key list, refusing a key the list
+ * does not declare, compared as bytes, and a key one object writes twice, which a
+ * parse cannot report because it keeps the last value.
+ */
+function checkKeys(text, file) {
+    try {
+        checkDocument(text, SCOPE_ROOT, `scope: ${file}`);
+    }
+    catch (error) {
+        if (error instanceof ConfigError) {
+            // The configuration's refusal names the nearest configuration key, which a
+            // scope document does not have.
+            throw new ScopeError(error.kind === "unimplemented-key"
+                ? `scope: ${file}: ${error.key} is not a declared key`
+                : error.message);
+        }
+        throw error;
+    }
+}
+/**
+ * Decodes the scope document at `file`. Decoding is strict: an undeclared key, a
+ * key written twice in one object, and a value of a type the document does not
+ * admit, `null` included, are errors, and a relative path inside the document
+ * resolves against the document's own directory.
  *
- * The `workspace` key the format declares is read and carries nothing here: it
+ * The `workspace` key the format declares is checked and carries nothing here: it
  * names the file a Go consumer resolves the target through, and a TypeScript
  * project resolves one through its own compiler configuration.
  */
@@ -85,11 +122,8 @@ export function readScope(host, file) {
     if (!isRecord(value)) {
         throw new ScopeError(`scope: ${file} is not one JSON object`);
     }
-    for (const name of Object.keys(value)) {
-        if (!DECLARED_KEYS.has(name)) {
-            throw new ScopeError(`scope: ${file}: ${name} is not a declared key`);
-        }
-    }
+    checkKeys(text, file);
+    stringMember(value, "workspace", "");
     const documentDir = dirnamePath(absolute);
     if (!Object.hasOwn(value, "target")) {
         throw new ScopeError(`scope: ${file} names no target`);

package/dist/src/serialization-contract.js

@@ -3,10 +3,12 @@
  * `JSON.stringify` or a call `ts.serializers` names, and those and `toJSON` and
  * `toString` where a value is passed to an `unknown` or `any` parameter of a function
  * outside the analysis. A function of the project handing such a parameter of its own
- * to a destination is one, holding back what that destination does, to a fixpoint.
+ * to a destination is one, holding back what that destination does, to a fixpoint. A
+ * function invoked through `Function.prototype.call`, `apply` or `bind` is the callee,
+ * given the arguments those methods pass it.
  */
-import { isArrowFunction, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isVariableDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
-import { SymbolFlags, TypeFlags, } from "@typescript/native/unstable/sync";
+import { isArrayLiteralExpression, isArrowFunction, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isVariableDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, resolvedTargets, valuesPassed } from "./calls.js";
 import { classMembers, memberComponent, typesAt } from "./class-members.js";
@@ -71,6 +73,55 @@ function evaluated(argument) {
     const value = isSpreadElement(argument) ? argument.expression : argument;
     return isParenthesizedExpression(value) ? evaluated(value.expression) : value;
 }
+/** The methods of `Function.prototype` that invoke a function with arguments of their own. */
+const FUNCTION_METHODS = new Set(["call", "apply", "bind"]);
+/** The interfaces of the standard library that declare those methods for a function value. */
+const FUNCTION_INTERFACES = new Set([
+    "Function",
+    "CallableFunction",
+    "NewableFunction",
+]);
+function unparenthesized(expression) {
+    return isParenthesizedExpression(expression)
+        ? unparenthesized(expression.expression)
+        : expression;
+}
+/**
+ * The invocation a call writes through a method of `Function.prototype`, read from
+ * the syntax alone: `f.call(self, a)`, `f.apply(self, [a])`, `f.bind(self, a)`, which
+ * binds `a`, and `f.bind(self, a)(b)`, which passes `b` after it. An `apply` argument
+ * that is no array literal is the value of the first parameter, whose elements it
+ * carries. Whether the method is the prototype's is resolution's to say.
+ */
+function throughMethod(call) {
+    const expression = unparenthesized(call.expression);
+    if (isPropertyAccessExpression(expression) && FUNCTION_METHODS.has(expression.name.text)) {
+        const [, ...rest] = call.arguments;
+        let passed = rest;
+        if (expression.name.text === "apply") {
+            const list = rest[0] === undefined ? undefined : unparenthesized(rest[0]);
+            passed = list === undefined ? [] : isArrayLiteralExpression(list) ? list.elements : [list];
+        }
+        return {
+            method: expression.name,
+            invocation: { callee: expression.expression, arguments: passed, indirect: true },
+        };
+    }
+    if (isCallExpression(expression)) {
+        const bound = unparenthesized(expression.expression);
+        if (isPropertyAccessExpression(bound) && bound.name.text === "bind") {
+            return {
+                method: bound.name,
+                invocation: {
+                    callee: bound.expression,
+                    arguments: [...expression.arguments.slice(1), ...call.arguments],
+                    indirect: true,
+                },
+            };
+        }
+    }
+    return undefined;
+}
 /**
  * Every call of the project's own files with the class `this` stands for there, and
  * every identifier-named parameter of every function, method and function-valued
@@ -146,9 +197,9 @@ function erasedParameters(project, parameters) {
     return bySymbol;
 }
 /** Each place a call's argument passes one of the erased parameters it can see. */
-function handedOn(project, sites, erased) {
+function handedOn(project, sites, erased, invocationOf) {
     const spellings = new Set([...erased.values()].map((parameter) => parameter.name.getText()));
-    const candidates = sites.flatMap((site) => site.call.arguments.flatMap((argument, index) => valuesPassed(argument)
+    const candidates = sites.flatMap((site) => invocationOf(site.call).arguments.flatMap((argument, index) => valuesPassed(argument)
         .filter((value) => spellings.has(value.name.getText()))
         .map((value) => ({ site, argument: index, value }))));
     const plain = candidates.filter((one) => !one.value.shorthand);
@@ -175,11 +226,20 @@ function destinations(input, chains, walked) {
     const checker = project.checker;
     const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
     const named = resolveEntries(project, held, [JSON_STRINGIFY, ...input.ts.serializers]).filter(namesADeclaration);
-    const callees = resolvedTargets(project, walked.sites.flatMap((site) => calleeName(site.call.expression) ?? []));
-    const calleeOf = (call) => {
-        const name = calleeName(call.expression);
-        return name === undefined ? undefined : callees.get(name);
-    };
+    const forms = new Map();
+    for (const site of walked.sites) {
+        const form = throughMethod(site.call);
+        if (form !== undefined) {
+            forms.set(site.call, form);
+        }
+    }
+    const callees = resolvedTargets(project, [
+        ...walked.sites.flatMap((site) => calleeName(site.call.expression) ?? []),
+        ...[...forms.values()].flatMap((form) => {
+            const name = calleeName(form.invocation.callee);
+            return name === undefined ? [form.method] : [form.method, name];
+        }),
+    ]);
     const erased = erasedParameters(project, walked.parameters);
     const byFunction = new Map();
     for (const parameter of erased.values()) {
@@ -188,15 +248,42 @@ function destinations(input, chains, walked) {
     const outside = (target) => target.declarations.length > 0 &&
         target.declarations.every((handle) => !own.has(handle.path) &&
             !input.consumers.some((root) => handle.path === root || handle.path.startsWith(`${root}/`)));
+    const invocation = (call) => {
+        const form = forms.get(call);
+        const method = form === undefined ? undefined : callees.get(form.method);
+        // Only the standard library's function methods pass their arguments on: the
+        // program's own `call` and `Reflect.apply` invoke nothing here.
+        if (form !== undefined &&
+            method !== undefined &&
+            outside(method) &&
+            FUNCTION_INTERFACES.has(method.getParent()?.name ?? "")) {
+            return form.invocation;
+        }
+        return { callee: call.expression, arguments: call.arguments, indirect: false };
+    };
+    const calleeOf = (call) => {
+        const name = calleeName(invocation(call).callee);
+        return name === undefined ? undefined : callees.get(name);
+    };
     const erasedArguments = new Map();
     const erasedAt = (call, argument) => {
         let indexes = erasedArguments.get(call);
         if (indexes === undefined) {
-            const signature = checker.getResolvedSignature(call);
-            indexes = new Set(call.arguments.flatMap((_unused, index) => {
-                const type = signature === undefined ? undefined : checker.getParameterType(signature, index);
-                return type !== undefined && (type.flags & ERASED) !== 0 ? [index] : [];
-            }));
+            const invoked = invocation(call);
+            // Through a method of the prototype the resolved signature is the method's, so
+            // the parameters are read off the callee's own signatures, any one erasing.
+            const type = invoked.indirect ? checker.getTypeAtLocation(invoked.callee) : undefined;
+            const signatures = invoked.indirect
+                ? type === undefined
+                    ? []
+                    : checker.getSignaturesOfType(type, SignatureKind.Call)
+                : [checker.getResolvedSignature(call)].filter((one) => one !== undefined);
+            indexes = new Set(invoked.arguments.flatMap((_unused, index) => signatures.some((signature) => {
+                const parameter = checker.getParameterType(signature, index);
+                return parameter !== undefined && (parameter.flags & ERASED) !== 0;
+            })
+                ? [index]
+                : []));
             erasedArguments.set(call, indexes);
         }
         return indexes.has(argument);
@@ -215,7 +302,10 @@ function destinations(input, chains, walked) {
         const declared = chains.declarationsOf(target);
         if (declared.length === 0) {
             return outside(target) && erasedAt(call, argument)
-                ? { reach: "conversions", callee: call.expression.getText().replace(/\s+/gu, "") }
+                ? {
+                    reach: "conversions",
+                    callee: invocation(call).callee.getText().replace(/\s+/gu, ""),
+                }
                 : undefined;
         }
         for (const fn of declared) {
@@ -227,7 +317,7 @@ function destinations(input, chains, walked) {
         }
         return undefined;
     };
-    const forwarded = handedOn(project, walked.sites, erased);
+    const forwarded = handedOn(project, walked.sites, erased, invocation);
     for (let moved = true; moved;) {
         moved = false;
         for (const one of forwarded) {
@@ -254,13 +344,13 @@ function destinations(input, chains, walked) {
         }
         return declared.some((fn) => (byFunction.get(fn) ?? []).some((parameter) => forwards.has(keyOf(parameter))));
     };
-    return { at, mayReceive };
+    return { invocation, at, mayReceive };
 }
 /** Each argument of a call that can receive one whose value carries a class of the target. */
 function flowsOf(project, held, sites, to) {
     const reach = valueReach(project, held);
     const arguments_ = sites.flatMap((site) => to.mayReceive(site.call)
-        ? site.call.arguments.flatMap((argument, index) => {
+        ? to.invocation(site.call).arguments.flatMap((argument, index) => {
             const value = evaluated(argument);
             return holdsNoInstance(value) ? [] : [{ site, argument: index, value }];
         })

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.1.0";
+export const CONTRACT_VERSION = "3.2.0";

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",

package/src/components.ts

@@ -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 type { Cascade } from "./config.ts";
@@ -17,25 +17,22 @@ const ID_DIGITS = 4;
 /** The index of a declaration the component walk has not reached. */
 const UNVISITED = -1;
 
-/** One dead component and its place in the acyclic graph over the components. */
+/** One dead component. */
 export interface Component {
   /** The analyzer's name, a solidus, and `c-` followed by the component's place in the order. */
   readonly id: string;
-  /** The component's declarations, by site. A dead member of a dead container is one of them. */
-  readonly members: readonly string[];
   /**
-   * The members no other dead component references and whose container is not dead,
-   * which are where a deletion starts. A cycle has as many as it has members no dead
-   * component outside it references.
+   * The component's declarations by site: its root members and every dead declaration
+   * that falls with them. A dead member of a dead container is one of them.
    */
-  readonly roots: readonly string[];
+  readonly members: readonly string[];
   /**
-   * What one deletion of the component removes: its members, and every dead declaration
-   * only this component reaches. A dead declaration two components both reach falls with
-   * neither and is counted by its own component.
+   * The root members, by site. A root member is a member of a cycle no dead declaration
+   * outside the cycle references, whose container is not dead; every member of such a
+   * cycle with a live container is one, so a component has at least one.
    */
-  readonly falls: readonly string[];
-  /** The source lines the deletion removes: the distinct lines {@link Component.falls} spans. */
+  readonly roots: readonly string[];
+  /** The source lines one deletion of the component removes: the distinct lines its members span. */
   readonly deletableLines: number;
 }
 
@@ -48,22 +45,22 @@ export interface Listing {
   readonly deletableLines: number;
 }
 
-/** 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: Component, cascade: Cascade): Listing {
   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: Graph,
@@ -75,26 +72,22 @@ export function componentsOf(
     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: number): string => 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])),
     };
   });
 }
@@ -185,10 +178,9 @@ interface Frame {
 }
 
 /**
- * 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: readonly (readonly number[])[]): {
   readonly componentOf: readonly number[];
@@ -257,45 +249,18 @@ function connected(adjacent: readonly (readonly number[])[]): {
   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(
+/** Per cycle, whether a dead declaration outside it references one of its members. */
+function referencedCycles(
   adjacent: readonly (readonly number[])[],
   componentOf: readonly number[],
   count: number,
-): { readonly edges: readonly (readonly number[])[]; readonly into: readonly number[] } {
-  const edges: number[][] = Array.from({ length: count }, () => []);
-  const into = Array.from({ length: count }, () => 0);
-  const seen = new Set<string>();
-  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: readonly (readonly number[])[],
-  componentOf: readonly number[],
 ): readonly boolean[] {
-  const referenced = adjacent.map(() => false);
+  const referenced = Array.from({ length: count }, () => 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;
       }
     }
   });
@@ -303,70 +268,42 @@ function externallyReferenced(
 }
 
 /**
- * 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: readonly (readonly number[])[],
-  members: readonly (readonly number[])[],
-): readonly number[] {
-  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);
+function joined(adjacent: readonly (readonly number[])[]): readonly (readonly number[])[] {
+  const leader = adjacent.map((_edges, position) => position);
+  const find = (position: number): number => {
+    let top = position;
+    while ((leader[top] ?? top) !== top) {
+      top = leader[top] ?? top;
     }
-  }
-  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: readonly (readonly number[])[],
-  members: readonly (readonly number[])[],
-  into: readonly number[],
-): readonly (readonly number[])[] {
-  // 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<number, readonly number[]>();
-  const owners = edges.map(() => 0);
-  edges.forEach((_targets, root) => {
-    if (into[root] !== 0) {
-      return;
+    // 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;
     }
-    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;
+    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<number, number[]>();
+  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()];
 }