@cplieger/deadset-ts 2.3.0 → 3.1.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 2.1.0 and ships the analyzer's foundation: one compiler session per run over 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, 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. The inventory and the reference pass are library functions the package exports; no other verb reports findings yet, so `analyze`, `explain`, `print-retained` 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 2.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. 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`, `print-retained` 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
 
@@ -35,7 +35,7 @@ npx deadset-ts version
 | `analyze`        | Analyze a project and print the findings                                        |
 | `explain`        | Explain one finding: the relation, the roots and the references that decided it |
 | `print-config`   | Print the resolved configuration and where each setting came from               |
-| `print-projects` | Print the compiler configuration of every project a run analyzes                |
+| `print-projects` | Print the identifier of every project a run analyzes                            |
 | `print-roots`    | Print every declaration the analysis keeps live without a reference, and why    |
 | `print-retained` | Print every symbol an exemption class held back, with the class                 |
 | `describe`       | Describe the analyzer: version, Contract version, supported issue kinds         |
@@ -49,7 +49,7 @@ npx deadset-ts version
 
 ## API
 
-The package exports the command line and the analyzer's own stages, for callers that embed them. Every one of them reads the platform through a `Host`: the filesystem, the directory relative paths resolve against, and the version of the package the analyzer was installed from. `bin/node-host.ts` is the Node one the command line binds; a caller embedding the analyzer, or running it on another platform, supplies its own and supplies its own version with it.
+The package exports the command line, for callers that run it in-process, and the vocabularies and helpers its output is spelled with. The command line reads the platform through a `Host`: the filesystem, the directory relative paths resolve against, and the version of the package the analyzer was installed from. `bin/node-host.ts` is the Node one the command line binds; a caller embedding the analyzer, or running it on another platform, supplies its own and supplies its own version with it.
 
 The command line:
 
@@ -62,18 +62,6 @@ The platform:
 - `Host`: the filesystem a run reads, the directory it reads relative paths against, and the analyzer's own version.
 - `DirectoryEntry`, `PathKind`: one entry of a directory read, and what one path names.
 
-The symbol inventory:
-
-- `inventory(project, host, targetRoot)`: every declaration one project's own files hold, in position order, down to class and type members.
-- `nodeKey(file, node)`: the key one declaration is recorded under.
-- `Inventory`, `InventorySymbol`, `InventoryCost`, `SymbolKind`, `Visibility`: one project's inventory, one declaration of it, what reading it cost, and the two vocabularies a declaration is described by.
-
-The reference pass:
-
-- `references(project, held, targetRoot, options)`: every reference from one project's own files to a declaration of its inventory, in position order, with the rules that classified files as test files.
-- `DEFAULT_BATCH_CAP`: the batch size the reference pass takes when its caller passes none; it is an option of the pass, not a configuration key. [Batch-cap calibration](docs/batch-cap-calibration.md) is the measurement that set it.
-- `Reference`, `References`, `ReferenceOptions`, `ReferenceCost`, `TestFileRule`, `Resolution`, `Use`: one reference, one project's set of them, how a run resolves them, what that cost, one test-file rule, which accessor answered a reference, and whether it reads or writes.
-
 Positions:
 
 - `renderPosition(file, root, offset)`: one compiler offset as a path, a line and a column, the column counting UTF-16 code units.
@@ -89,9 +77,12 @@ Stable symbol references:
 - `REF_EXPRESSIONS`: one regular expression per form the grammar defines.
 - `Module`, `Component`, `Fragment`, `DependencySection`: the module half of a reference, one component of its fragment, what the fragment names, and the manifest section a dependency was declared in.
 
-Versions:
+Entry points:
 
 - `DECLINED_CONVENTIONS`, `DeclinedConvention`: the entry-point conventions of other tools the analysis does not read, one row per tool or convention with the reason.
+
+Versions:
+
 - `CONTRACT_VERSION`: the contract version this analyzer implements.
 
 ## Contributing

package/dist/src/alias-chain.js

@@ -0,0 +1,96 @@
+/**
+ * Where an import or export chain leads in one project: from one symbol to each
+ * declaration of the target it is, and along the chain of aliases it heads to each
+ * declaration every link of that chain is.
+ */
+import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { nodeKey } from "./inventory.js";
+/**
+ * The chain walks over one project, against the declarations of `held`, the same
+ * project's inventory.
+ *
+ * A declaration handle carries the file it is in, so whether it is one of the
+ * project's own files is answered before the handle is resolved: a declaration of a
+ * library file is never fetched to find out that the inventory does not hold it.
+ */
+export function aliasChains(project, held) {
+    const ownFiles = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const steps = new Map();
+    const chains = new Map();
+    let asked = 0;
+    const declarationsOf = (symbol) => {
+        const ids = [];
+        for (const handle of symbol.declarations) {
+            if (!ownFiles.has(handle.path)) {
+                continue;
+            }
+            const node = project.declarationAt(handle)?.node;
+            const id = node === undefined ? undefined : held.declarations.get(nodeKey(node.getSourceFile(), node));
+            if (id !== undefined && !ids.includes(id)) {
+                ids.push(id);
+            }
+        }
+        return ids;
+    };
+    /**
+     * What one alias names, one link along. Only a symbol the binder flagged an alias is
+     * asked, which is the condition the step asserts on: a default export of an
+     * expression is written in an alias form and names nothing declared elsewhere, so its
+     * chain ends at itself.
+     */
+    const stepOf = (symbol) => {
+        if ((symbol.flags & SymbolFlags.Alias) === 0) {
+            return undefined;
+        }
+        if (steps.has(symbol.id)) {
+            return steps.get(symbol.id);
+        }
+        const next = project.aliasStepOf(symbol);
+        asked += 1;
+        steps.set(symbol.id, next);
+        return next;
+    };
+    const chainOf = (symbol) => {
+        const cached = chains.get(symbol.id);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const targets = [];
+        const walked = new Set();
+        let at = symbol;
+        let stepped = false;
+        while (at !== undefined && !walked.has(at.id)) {
+            walked.add(at.id);
+            for (const id of declarationsOf(at)) {
+                if (!targets.some((target) => target.id === id)) {
+                    targets.push({ id, stepped });
+                }
+            }
+            at = stepOf(at);
+            stepped = true;
+        }
+        chains.set(symbol.id, targets);
+        return targets;
+    };
+    const nextDeclared = (symbol) => {
+        const walked = new Set([symbol.id]);
+        let at = stepOf(symbol);
+        while (at !== undefined && !walked.has(at.id)) {
+            walked.add(at.id);
+            const ids = declarationsOf(at);
+            if (ids.length > 0) {
+                return ids;
+            }
+            at = stepOf(at);
+        }
+        return [];
+    };
+    return {
+        declarationsOf,
+        chainOf,
+        nextDeclared,
+        get steps() {
+            return asked;
+        },
+    };
+}

package/dist/src/analysis.js

@@ -10,8 +10,10 @@
 import { diagnosticErrors, discoverProjects, DiscoveryError } from "./discover.js";
 import { inventory } from "./inventory.js";
 import { readManifest } from "./manifest.js";
+import { matrixOf, sweepMatrix } from "./matrix.js";
 import { relativePath, resolvePath } from "./paths.js";
 import { byPosition } from "./position.js";
+import { references } from "./references.js";
 import { roots, unmatchedEverywhere, unmatchedRoots } from "./roots.js";
 import { diagnosticsOf, runSession } from "./session.js";
 /** The setting whose source decides where a finding about a configured root sits. */
@@ -38,19 +40,17 @@ function compare(a, b) {
     return a < b ? -1 : 1;
 }
 /**
- * The root set of the run the scope and the configuration describe.
- *
- * Every project is read for errors before anything else, and a project carrying one
- * fails the run with no root set, as every verb that reads declarations does. A
- * configured string is a finding when it names nothing in every project, and the
- * finding sits in the document that declared the roots.
+ * Reads every project the scope discovers, in one snapshot: each is checked for errors
+ * first, then enumerated, then rooted, and `stage` reads the rest of what it needs from
+ * the project while its view is open. A project carrying an error fails the run with no
+ * answer, as every verb that reads declarations does.
  */
-export function runRoots(engine, host, scope, config, provenance) {
+function readProjects(engine, host, scope, config, stage) {
     const targetRoot = scope.target.path;
-    const discovered = discoverProjects(engine, host, scope);
-    const manifest = readManifest(host, targetRoot);
+    const discovered = discoverProjects(engine, host, scope, config.analysis.configurations);
+    const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
     const options = {
-        manifest,
+        manifest: readManifest(host, targetRoot),
         patterns: config.rootPatterns,
         entryFiles: config.ts.entryFiles,
         testFiles: config.ts.testFiles,
@@ -64,18 +64,28 @@ export function runRoots(engine, host, scope, config, provenance) {
             return undefined;
         }
         const held = inventory(project, host, targetRoot);
-        return { held, rooted: roots(project, held, targetRoot, options) };
+        const rooted = roots(project, held, targetRoot, options);
+        const configuration = ids.get(project.configFile) ?? project.configFile;
+        return stage(project, { configuration, held, rooted });
     });
     if (failures.length > 0) {
         throw new DiscoveryError(`${String(failures.length)} error(s); no answer was produced`, failures);
     }
+    return projects.filter((answer) => answer !== undefined);
+}
+/**
+ * The root set of the run the scope and the configuration describe.
+ *
+ * A configured string is a finding when it names nothing in every project, and the
+ * finding sits in the document that declared the roots.
+ */
+export function runRoots(engine, host, scope, config, provenance) {
+    const targetRoot = scope.target.path;
+    const projects = readProjects(engine, host, scope, config, (_project, read) => read);
     const configurations = [];
     const merged = new Map();
     for (const answer of projects) {
-        if (answer === undefined) {
-            continue;
-        }
-        const configuration = relativePath(targetRoot, answer.rooted.configFile) ?? answer.rooted.configFile;
+        const configuration = answer.configuration;
         configurations.push(configuration);
         const symbols = new Map(answer.held.symbols.map((symbol) => [symbol.id, symbol]));
         for (const root of answer.rooted.liveUnderReachability) {
@@ -100,10 +110,34 @@ export function runRoots(engine, host, scope, config, provenance) {
         }
     }
     const ordered = [...merged.values()].sort((a, b) => byPosition(a.position, b.position) || compare(a.kind, b.kind) || compare(a.source, b.source));
-    const unmatched = unmatchedEverywhere(config.rootPatterns, projects.flatMap((answer) => (answer === undefined ? [] : [answer.rooted])));
+    const unmatched = unmatchedEverywhere(config.rootPatterns, projects.map((answer) => answer.rooted));
     return {
         configurations,
         roots: ordered,
         findings: unmatchedRoots(unmatched, documentOf(host, provenance, ROOTS_SETTING, targetRoot)),
     };
 }
+/**
+ * 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.
+ */
+export function runSweep(engine, host, scope, config, input) {
+    const targetRoot = scope.target.path;
+    const configured = readProjects(engine, host, scope, config, (project, read) => {
+        const resolved = references(project, read.held, targetRoot, {
+            testFiles: config.ts.testFiles,
+        });
+        return {
+            configuration: read.configuration,
+            symbols: read.held.symbols,
+            references: resolved.references,
+            roots: read.rooted.liveUnderReachability,
+            testFiles: resolved.testFilePaths,
+        };
+    });
+    const matrix = matrixOf(configured);
+    return { matrix, sweep: sweepMatrix(matrix, input) };
+}

package/dist/src/components.js

@@ -0,0 +1,289 @@
+/**
+ * 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.
+ */
+import { OUTSIDE } from "./graph.js";
+/** The name every component identifier this analyzer mints starts with. */
+const ANALYZER = "deadset-ts";
+/** The fewest digits a component identifier's number is written with. */
+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. */
+export function listing(component, cascade) {
+    return {
+        roots: component.roots,
+        members: cascade === "full" ? component.members : [],
+        symbolCount: component.falls.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.
+ */
+export function componentsOf(graph, dead, testOfDeadCode) {
+    const { at, adjacent } = deadSubgraph(graph, dead, testOfDeadCode);
+    if (at.length === 0) {
+        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 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.
+            const container = graph.parent[at[position] ?? 0] ?? OUTSIDE;
+            return outsideReference[position] !== true && dead[container] !== true;
+        });
+        const fallen = falls[group] ?? [];
+        return {
+            id: `${ANALYZER}/c-${String(place + 1).padStart(ID_DIGITS, "0")}`,
+            members: own.map(idOf),
+            roots: roots.map(idOf),
+            falls: fallen.map(idOf),
+            deletableLines: linesSpanned(fallen.map((position) => graph.symbols[at[position] ?? 0])),
+        };
+    });
+}
+/**
+ * The distinct source lines a set of declarations spans, each declaration at least the
+ * line it starts on. A member written inside its container's span adds no line, because
+ * deleting the container removes it.
+ */
+function linesSpanned(symbols) {
+    const byPath = new Map();
+    for (const symbol of symbols) {
+        if (symbol === undefined) {
+            continue;
+        }
+        const span = [
+            symbol.position.line,
+            Math.max(symbol.position.line, symbol.endLine),
+        ];
+        const spans = byPath.get(symbol.position.path);
+        if (spans === undefined) {
+            byPath.set(symbol.position.path, [span]);
+        }
+        else {
+            spans.push(span);
+        }
+    }
+    let total = 0;
+    for (const spans of byPath.values()) {
+        spans.sort((a, b) => a[0] - b[0]);
+        let end = 0;
+        for (const [first, last] of spans) {
+            total += Math.max(0, last - Math.max(first - 1, end));
+            end = Math.max(end, last);
+        }
+    }
+    return total;
+}
+/**
+ * The dead declarations by their place in the subgraph, and the edges between them: each
+ * reference one makes to another, an edge each way between a dead member and its dead
+ * container (one direction alone leaves the member a component the container reaches),
+ * and an edge back from each production target of an admitted test, which puts the test in
+ * the component of the code it exercises because a subject never references its test.
+ */
+function deadSubgraph(graph, dead, testOfDeadCode) {
+    const at = [];
+    const position = graph.symbols.map((_symbol, index) => {
+        if (dead[index] !== true) {
+            return UNVISITED;
+        }
+        at.push(index);
+        return at.length - 1;
+    });
+    const adjacent = at.map(() => []);
+    at.forEach((index, from) => {
+        for (const edge of graph.out[index] ?? []) {
+            const to = position[edge.to] ?? UNVISITED;
+            if (to === UNVISITED) {
+                continue;
+            }
+            adjacent[from]?.push(to);
+            if (testOfDeadCode[index] === true &&
+                graph.test[edge.to] !== true &&
+                graph.subject[edge.to] === true) {
+                adjacent[to]?.push(from);
+            }
+        }
+        const container = position[graph.parent[index] ?? OUTSIDE] ?? UNVISITED;
+        if (container !== UNVISITED) {
+            adjacent[from]?.push(container);
+            adjacent[container]?.push(from);
+        }
+    });
+    return { at, adjacent };
+}
+/**
+ * Each declaration's component and each component'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.
+ */
+function connected(adjacent) {
+    const index = adjacent.map(() => UNVISITED);
+    const low = adjacent.map(() => UNVISITED);
+    const onStack = adjacent.map(() => false);
+    const stack = [];
+    const members = [];
+    let next = 0;
+    const open = (at, frames) => {
+        index[at] = next;
+        low[at] = next;
+        next += 1;
+        stack.push(at);
+        onStack[at] = true;
+        frames.push({ at, next: 0 });
+    };
+    adjacent.forEach((_edges, start) => {
+        if (index[start] !== UNVISITED) {
+            return;
+        }
+        const frames = [];
+        open(start, frames);
+        for (let frame = frames.at(-1); frame !== undefined; frame = frames.at(-1)) {
+            const edges = adjacent[frame.at] ?? [];
+            const to = edges[frame.next];
+            if (to !== undefined) {
+                frame.next += 1;
+                if (index[to] === UNVISITED) {
+                    open(to, frames);
+                }
+                else if (onStack[to] === true) {
+                    low[frame.at] = Math.min(low[frame.at] ?? 0, index[to] ?? 0);
+                }
+                continue;
+            }
+            frames.pop();
+            const parent = frames.at(-1);
+            if (parent !== undefined) {
+                low[parent.at] = Math.min(low[parent.at] ?? 0, low[frame.at] ?? 0);
+            }
+            if (low[frame.at] !== index[frame.at]) {
+                continue;
+            }
+            const group = [];
+            for (let top = stack.pop(); top !== undefined; top = stack.pop()) {
+                onStack[top] = false;
+                group.push(top);
+                if (top === frame.at) {
+                    break;
+                }
+            }
+            members.push(group.sort((a, b) => a - b));
+        }
+    });
+    const componentOf = adjacent.map(() => 0);
+    members.forEach((group, component) => {
+        for (const at of group) {
+            componentOf[at] = component;
+        }
+    });
+    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();
+    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;
+            }
+        }
+    });
+    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.
+ */
+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;
+        }
+    });
+    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] ?? []));
+            }
+        }
+        return set.sort((a, b) => a - b);
+    });
+}