@optave/codegraph 3.11.0 → 3.11.1

package/src/features/structure-query.ts

@@ -227,6 +227,96 @@ interface HotspotsDataOpts {
   noTests?: boolean;
 }
 
+type HotspotEntry = {
+  name: string;
+  kind: string;
+  lineCount: number | null;
+  symbolCount: number | null;
+  importCount: number | null;
+  exportCount: number | null;
+  fanIn: number | null;
+  fanOut: number | null;
+  cohesion: number | null;
+  fileCount: number | null;
+  density: number;
+  coupling: number;
+};
+
+/** Compute density from either fileCount/symbolCount or lineCount/symbolCount. */
+function computeHotspotDensity(
+  symbolCount: number | null,
+  fileCount: number | null,
+  lineCount: number | null,
+): number {
+  if ((fileCount ?? 0) > 0) return (symbolCount || 0) / (fileCount ?? 1);
+  if ((lineCount ?? 0) > 0) return (symbolCount || 0) / (lineCount ?? 1);
+  return 0;
+}
+
+/** Map a native-engine hotspot row (camelCase keys) to the public HotspotEntry shape. */
+function mapNativeHotspotRow(r: {
+  name: string;
+  kind: string;
+  lineCount: number | null;
+  symbolCount: number | null;
+  importCount: number | null;
+  exportCount: number | null;
+  fanIn: number | null;
+  fanOut: number | null;
+  cohesion: number | null;
+  fileCount: number | null;
+}): HotspotEntry {
+  return {
+    name: r.name,
+    kind: r.kind,
+    lineCount: r.lineCount,
+    symbolCount: r.symbolCount,
+    importCount: r.importCount,
+    exportCount: r.exportCount,
+    fanIn: r.fanIn,
+    fanOut: r.fanOut,
+    cohesion: r.cohesion,
+    fileCount: r.fileCount,
+    density: computeHotspotDensity(r.symbolCount, r.fileCount, r.lineCount),
+    coupling: (r.fanIn || 0) + (r.fanOut || 0),
+  };
+}
+
+/** Map a JS-path hotspot row (snake_case keys from SQLite) to the public HotspotEntry shape. */
+function mapJsHotspotRow(r: HotspotRow): HotspotEntry {
+  return {
+    name: r.name,
+    kind: r.kind,
+    lineCount: r.line_count,
+    symbolCount: r.symbol_count,
+    importCount: r.import_count,
+    exportCount: r.export_count,
+    fanIn: r.fan_in,
+    fanOut: r.fan_out,
+    cohesion: r.cohesion,
+    fileCount: r.file_count,
+    density: computeHotspotDensity(r.symbol_count, r.file_count, r.line_count),
+    coupling: (r.fan_in || 0) + (r.fan_out || 0),
+  };
+}
+
+/** ORDER BY clause for each ranking dimension (strategy pattern). */
+const HOTSPOT_ORDER_BY: Record<string, string> = {
+  'fan-in': 'nm.fan_in DESC NULLS LAST',
+  'fan-out': 'nm.fan_out DESC NULLS LAST',
+  density: 'nm.symbol_count DESC NULLS LAST',
+  coupling: '(COALESCE(nm.fan_in, 0) + COALESCE(nm.fan_out, 0)) DESC NULLS LAST',
+};
+
+/** Build the JS-path SQL query for a given metric and test filter. */
+function buildHotspotQuery(metric: string, testFilter: string): string {
+  const orderBy = HOTSPOT_ORDER_BY[metric] ?? HOTSPOT_ORDER_BY['fan-in'];
+  return `SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
+                 nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
+          FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
+          WHERE n.kind = ? ${testFilter} ORDER BY ${orderBy} LIMIT ?`;
+}
+
 export function hotspotsData(
   customDbPath?: string,
   opts: HotspotsDataOpts = {},
@@ -242,96 +332,21 @@ export function hotspotsData(
     const level = opts.level || 'file';
     const limit = opts.limit || 10;
     const noTests = opts.noTests || false;
-
     const kind = level === 'directory' ? 'directory' : 'file';
 
-    const mapRow = (r: {
-      name: string;
-      kind: string;
-      lineCount: number | null;
-      symbolCount: number | null;
-      importCount: number | null;
-      exportCount: number | null;
-      fanIn: number | null;
-      fanOut: number | null;
-      cohesion: number | null;
-      fileCount: number | null;
-    }) => ({
-      name: r.name,
-      kind: r.kind,
-      lineCount: r.lineCount,
-      symbolCount: r.symbolCount,
-      importCount: r.importCount,
-      exportCount: r.exportCount,
-      fanIn: r.fanIn,
-      fanOut: r.fanOut,
-      cohesion: r.cohesion,
-      fileCount: r.fileCount,
-      density:
-        (r.fileCount ?? 0) > 0
-          ? (r.symbolCount || 0) / (r.fileCount ?? 1)
-          : (r.lineCount ?? 0) > 0
-            ? (r.symbolCount || 0) / (r.lineCount ?? 1)
-            : 0,
-      coupling: (r.fanIn || 0) + (r.fanOut || 0),
-    });
-
     // ── Native fast path: single query instead of 4 eagerly prepared ──
     if (nativeDb?.getHotspots) {
       const rows = nativeDb.getHotspots(kind, metric, noTests, limit);
-      const hotspots = rows.map(mapRow);
+      const hotspots = rows.map(mapNativeHotspotRow);
       const base = { metric, level, limit, hotspots };
       return paginateResult(base, 'hotspots', { limit: opts.limit, offset: opts.offset });
     }
 
     // ── JS fallback ───────────────────────────────────────────────────
     const testFilter = testFilterSQL('n.name', noTests && kind === 'file');
-
-    const HOTSPOT_QUERIES: Record<string, { all(...params: unknown[]): HotspotRow[] }> = {
-      'fan-in': db.prepare(`
-        SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
-               nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = ? ${testFilter} ORDER BY nm.fan_in DESC NULLS LAST LIMIT ?`),
-      'fan-out': db.prepare(`
-        SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
-               nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = ? ${testFilter} ORDER BY nm.fan_out DESC NULLS LAST LIMIT ?`),
-      density: db.prepare(`
-        SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
-               nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = ? ${testFilter} ORDER BY nm.symbol_count DESC NULLS LAST LIMIT ?`),
-      coupling: db.prepare(`
-        SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
-               nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = ? ${testFilter} ORDER BY (COALESCE(nm.fan_in, 0) + COALESCE(nm.fan_out, 0)) DESC NULLS LAST LIMIT ?`),
-    };
-
-    const stmt = HOTSPOT_QUERIES[metric] ?? HOTSPOT_QUERIES['fan-in'];
-    const rows = stmt!.all(kind, limit);
-
-    const hotspots = rows.map((r) => ({
-      name: r.name,
-      kind: r.kind,
-      lineCount: r.line_count,
-      symbolCount: r.symbol_count,
-      importCount: r.import_count,
-      exportCount: r.export_count,
-      fanIn: r.fan_in,
-      fanOut: r.fan_out,
-      cohesion: r.cohesion,
-      fileCount: r.file_count,
-      density:
-        (r.file_count ?? 0) > 0
-          ? (r.symbol_count || 0) / (r.file_count ?? 1)
-          : (r.line_count ?? 0) > 0
-            ? (r.symbol_count || 0) / (r.line_count ?? 1)
-            : 0,
-      coupling: (r.fan_in || 0) + (r.fan_out || 0),
-    }));
+    const stmt = db.prepare(buildHotspotQuery(metric, testFilter));
+    const rows = stmt.all(kind, limit) as HotspotRow[];
+    const hotspots = rows.map(mapJsHotspotRow);
 
     const base = { metric, level, limit, hotspots };
     return paginateResult(base, 'hotspots', { limit: opts.limit, offset: opts.offset });

package/src/features/structure.ts

@@ -532,6 +532,56 @@ function batchUpdateRoles(
   })();
 }
 
+interface CallableNodeRow {
+  id: number;
+  name: string;
+  kind: string;
+  file: string;
+  fan_in: number;
+  fan_out: number;
+}
+
+/** Build the activeFiles set: files with at least one callable connected to the graph. */
+function buildActiveFilesSet(rows: CallableNodeRow[]): Set<string> {
+  const activeFiles = new Set<string>();
+  for (const r of rows) {
+    if ((r.fan_in > 0 || r.fan_out > 0) && r.kind !== 'constant') {
+      activeFiles.add(r.file);
+    }
+  }
+  return activeFiles;
+}
+
+/** Map callable rows to classifier input objects, attaching exported/prod-fan-in/active-file metadata. */
+function buildClassifierInput(
+  rows: CallableNodeRow[],
+  exportedIds: Set<number>,
+  prodFanInMap: Map<number, number>,
+  activeFiles: Set<string>,
+): Array<{
+  id: string;
+  name: string;
+  kind: string;
+  file: string;
+  fanIn: number;
+  fanOut: number;
+  isExported: boolean;
+  productionFanIn: number;
+  hasActiveFileSiblings: boolean | undefined;
+}> {
+  return rows.map((r) => ({
+    id: String(r.id),
+    name: r.name,
+    kind: r.kind,
+    file: r.file,
+    fanIn: r.fan_in,
+    fanOut: r.fan_out,
+    isExported: exportedIds.has(r.id),
+    productionFanIn: prodFanInMap.get(r.id) || 0,
+    hasActiveFileSiblings: r.kind === 'constant' ? activeFiles.has(r.file) : undefined,
+  }));
+}
+
 function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSummary): RoleSummary {
   // Leaf kinds (parameter, property) can never have callers/callees.
   // Classify them directly as dead-leaf without the expensive fan-in/fan-out JOINs.
@@ -558,14 +608,7 @@ function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSumm
       ) fo ON n.id = fo.source_id
       WHERE n.kind NOT IN ('file', 'directory', 'parameter', 'property')`,
     )
-    .all() as {
-    id: number;
-    name: string;
-    kind: string;
-    file: string;
-    fan_in: number;
-    fan_out: number;
-  }[];
+    .all() as CallableNodeRow[];
 
   if (rows.length === 0 && leafRows.length === 0) return emptySummary;
 
@@ -629,28 +672,9 @@ function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSumm
     prodFanInMap.set(r.target_id, r.cnt);
   }
 
-  // Files with at least one callable (non-constant) connected to the graph.
-  // Constants in these files are likely consumed locally via identifier reference.
-  const activeFiles = new Set<string>();
-  for (const r of rows) {
-    if ((r.fan_in > 0 || r.fan_out > 0) && r.kind !== 'constant') {
-      activeFiles.add(r.file);
-    }
-  }
-
   // Delegate classification to the pure-logic classifier
-  const classifierInput = rows.map((r) => ({
-    id: String(r.id),
-    name: r.name,
-    kind: r.kind,
-    file: r.file,
-    fanIn: r.fan_in,
-    fanOut: r.fan_out,
-    isExported: exportedIds.has(r.id),
-    productionFanIn: prodFanInMap.get(r.id) || 0,
-    hasActiveFileSiblings: r.kind === 'constant' ? activeFiles.has(r.file) : undefined,
-  }));
-
+  const activeFiles = buildActiveFilesSet(rows);
+  const classifierInput = buildClassifierInput(rows, exportedIds, prodFanInMap, activeFiles);
   const roleMap = classifyRoles(classifierInput);
 
   const { summary, idsByRole } = buildRoleSummary(rows, leafRows, roleMap, emptySummary);
@@ -733,14 +757,7 @@ function classifyNodeRolesIncremental(
       WHERE n.kind NOT IN ('file', 'directory', 'parameter', 'property')
         AND n.file IN (${placeholders})`,
     )
-    .all(...allAffectedFiles) as {
-    id: number;
-    name: string;
-    kind: string;
-    file: string;
-    fan_in: number;
-    fan_out: number;
-  }[];
+    .all(...allAffectedFiles) as CallableNodeRow[];
 
   if (rows.length === 0 && leafRows.length === 0) return emptySummary;
 
@@ -810,25 +827,8 @@ function classifyNodeRolesIncremental(
   }
 
   // 5. Classify affected nodes using global medians
-  const activeFiles = new Set<string>();
-  for (const r of rows) {
-    if ((r.fan_in > 0 || r.fan_out > 0) && r.kind !== 'constant') {
-      activeFiles.add(r.file);
-    }
-  }
-
-  const classifierInput = rows.map((r) => ({
-    id: String(r.id),
-    name: r.name,
-    kind: r.kind,
-    file: r.file,
-    fanIn: r.fan_in,
-    fanOut: r.fan_out,
-    isExported: exportedIds.has(r.id),
-    productionFanIn: prodFanInMap.get(r.id) || 0,
-    hasActiveFileSiblings: r.kind === 'constant' ? activeFiles.has(r.file) : undefined,
-  }));
-
+  const activeFiles = buildActiveFilesSet(rows);
+  const classifierInput = buildClassifierInput(rows, exportedIds, prodFanInMap, activeFiles);
   const roleMap = classifyRoles(classifierInput, globalMedians);
 
   // 6. Build summary (only for affected nodes) and update only those nodes

package/src/graph/algorithms/leiden/optimiser.ts

@@ -88,12 +88,10 @@ export function runLouvainUndirectedModularity(
   optionsInput: LeidenOptions = {},
 ): LouvainResult {
   const options: NormalizedOptions = normalizeOptions(optionsInput);
-  let currentGraph: CodeGraph = graph;
-  const levels: LevelEntry[] = [];
   const rngSource = createRng(options.randomSeed);
   const random: () => number = () => rngSource.nextDouble();
 
-  const baseGraphAdapter: GraphAdapter = makeGraphAdapter(currentGraph, {
+  const baseGraphAdapter: GraphAdapter = makeGraphAdapter(graph, {
     directed: options.directed,
     ...optionsInput,
   });
@@ -101,98 +99,27 @@ export function runLouvainUndirectedModularity(
   const originalToCurrent = new Int32Array(origN);
   for (let i = 0; i < origN; i++) originalToCurrent[i] = i;
 
-  let fixedNodeMask: Uint8Array | null = null;
-  if (options.fixedNodes) {
-    const fixed = new Uint8Array(origN);
-    const asSet: Set<string> =
-      options.fixedNodes instanceof Set ? options.fixedNodes : new Set(options.fixedNodes);
-    for (const id of asSet) {
-      const idx = baseGraphAdapter.idToIndex.get(String(id));
-      if (idx != null) fixed[idx] = 1;
-    }
-    fixedNodeMask = fixed;
-  }
+  const fixedNodeMask: Uint8Array | null = buildFixedNodeMask(baseGraphAdapter, options.fixedNodes);
 
+  const levels: LevelEntry[] = [];
+  let currentGraph: CodeGraph = graph;
   for (let level = 0; level < options.maxLevels; level++) {
     const graphAdapter: GraphAdapter =
       level === 0
         ? baseGraphAdapter
         : makeGraphAdapter(currentGraph, { directed: options.directed, ...optionsInput });
-    const partition: Partition = makePartition(graphAdapter);
-    partition.graph = graphAdapter;
-    partition.initializeAggregates();
-
-    const order = new Int32Array(graphAdapter.n);
-    for (let i = 0; i < graphAdapter.n; i++) order[i] = i;
-
-    let improved: boolean = true;
-    let localPasses: number = 0;
-    const strategyCode: CandidateStrategyCode = options.candidateStrategyCode;
-    while (improved) {
-      improved = false;
-      localPasses++;
-      shuffleArrayInPlace(order, random);
-      for (let idx = 0; idx < order.length; idx++) {
-        const nodeIndex: number = order[idx]!;
-        if (level === 0 && fixedNodeMask && fixedNodeMask[nodeIndex]) continue;
-        const candidateCount: number = partition.accumulateNeighborCommunityEdgeWeights(nodeIndex);
-        const { bestCommunityId, bestGain } = findBestCommunityMove(
-          partition,
-          graphAdapter,
-          nodeIndex,
-          candidateCount,
-          strategyCode,
-          options,
-          random,
-        );
-        if (bestCommunityId !== partition.nodeCommunity[nodeIndex]! && bestGain > GAIN_EPSILON) {
-          partition.moveNodeToCommunity(nodeIndex, bestCommunityId);
-          improved = true;
-        }
-      }
-      if (localPasses >= options.maxLocalPasses) break;
-    }
-
-    renumberCommunities(partition, options.preserveLabels);
-
-    let effectivePartition: Partition = partition;
-    if (options.refine) {
-      const refined: Partition = refineWithinCoarseCommunities(
-        graphAdapter,
-        partition,
-        random,
-        options,
-        level === 0 ? fixedNodeMask : null,
-      );
-      // Post-refinement: split any disconnected communities into their
-      // connected components. This is the cheap O(V+E) alternative to
-      // checking gamma-connectedness on every candidate during refinement.
-      // A disconnected community violates even basic connectivity, so
-      // splitting is always correct.
-      splitDisconnectedCommunities(graphAdapter, refined);
-      renumberCommunities(refined, options.preserveLabels);
-      effectivePartition = refined;
-    }
+    const levelOutcome = runLevel(
+      graphAdapter,
+      options,
+      random,
+      level === 0 ? fixedNodeMask : null,
+    );
 
-    levels.push({ graph: graphAdapter, partition: effectivePartition });
-    const fineToCoarse: Int32Array = effectivePartition.nodeCommunity;
-    for (let i = 0; i < originalToCurrent.length; i++) {
-      originalToCurrent[i] = fineToCoarse[originalToCurrent[i]!]!;
-    }
+    levels.push({ graph: graphAdapter, partition: levelOutcome.effectivePartition });
+    applyFineToCoarseMapping(originalToCurrent, levelOutcome.effectivePartition.nodeCommunity);
 
-    // Terminate when no further coarsening is possible. Check both the
-    // move-phase partition (did the greedy phase find merges?) and the
-    // effective partition that feeds buildCoarseGraph (would coarsening
-    // actually reduce the graph?). When refine is enabled the refined
-    // partition starts from singletons and may have more communities than
-    // the move phase found, so checking only effectivePartition would
-    // cause premature termination.
-    if (
-      partition.communityCount === graphAdapter.n &&
-      effectivePartition.communityCount === graphAdapter.n
-    )
-      break;
-    currentGraph = buildCoarseGraph(graphAdapter, effectivePartition);
+    if (levelOutcome.terminate) break;
+    currentGraph = buildCoarseGraph(graphAdapter, levelOutcome.effectivePartition);
   }
 
   const last: LevelEntry = levels[levels.length - 1]!;
@@ -206,6 +133,134 @@ export function runLouvainUndirectedModularity(
   };
 }
 
+/**
+ * Build a fixed-node mask aligned with the base graph adapter's node indices.
+ * Returns null when no fixed nodes are configured.
+ */
+function buildFixedNodeMask(
+  baseGraphAdapter: GraphAdapter,
+  fixedNodes: Set<string> | string[] | undefined,
+): Uint8Array | null {
+  if (!fixedNodes) return null;
+  const mask = new Uint8Array(baseGraphAdapter.n);
+  const asSet: Set<string> = fixedNodes instanceof Set ? fixedNodes : new Set(fixedNodes);
+  for (const id of asSet) {
+    const idx = baseGraphAdapter.idToIndex.get(String(id));
+    if (idx != null) mask[idx] = 1;
+  }
+  return mask;
+}
+
+interface LevelOutcome {
+  effectivePartition: Partition;
+  terminate: boolean;
+}
+
+/**
+ * Run one level of the Louvain/Leiden pipeline: greedy local-move phase,
+ * optional Leiden refinement, and a termination check. Returns the
+ * partition that feeds the next coarse graph plus a `terminate` flag set
+ * when no further coarsening is possible.
+ */
+function runLevel(
+  graphAdapter: GraphAdapter,
+  options: NormalizedOptions,
+  random: () => number,
+  fixedNodeMask: Uint8Array | null,
+): LevelOutcome {
+  const partition: Partition = makePartition(graphAdapter);
+  partition.graph = graphAdapter;
+  partition.initializeAggregates();
+
+  runLocalMovePhase(graphAdapter, partition, options, random, fixedNodeMask);
+  renumberCommunities(partition, options.preserveLabels);
+
+  let effectivePartition: Partition = partition;
+  if (options.refine) {
+    const refined: Partition = refineWithinCoarseCommunities(
+      graphAdapter,
+      partition,
+      random,
+      options,
+      fixedNodeMask,
+    );
+    // Post-refinement: split any disconnected communities into their
+    // connected components. This is the cheap O(V+E) alternative to
+    // checking gamma-connectedness on every candidate during refinement.
+    // A disconnected community violates even basic connectivity, so
+    // splitting is always correct.
+    splitDisconnectedCommunities(graphAdapter, refined);
+    renumberCommunities(refined, options.preserveLabels);
+    effectivePartition = refined;
+  }
+
+  // Terminate when no further coarsening is possible. Check both the
+  // move-phase partition (did the greedy phase find merges?) and the
+  // effective partition that feeds buildCoarseGraph (would coarsening
+  // actually reduce the graph?). When refine is enabled the refined
+  // partition starts from singletons and may have more communities than
+  // the move phase found, so checking only effectivePartition would
+  // cause premature termination.
+  const terminate =
+    partition.communityCount === graphAdapter.n &&
+    effectivePartition.communityCount === graphAdapter.n;
+  return { effectivePartition, terminate };
+}
+
+/**
+ * Greedy local-move phase: iterate randomly over nodes, moving each to the
+ * best community among the candidate set. Loops until no improvement or
+ * `maxLocalPasses` is reached.
+ */
+function runLocalMovePhase(
+  graphAdapter: GraphAdapter,
+  partition: Partition,
+  options: NormalizedOptions,
+  random: () => number,
+  fixedNodeMask: Uint8Array | null,
+): void {
+  const order = new Int32Array(graphAdapter.n);
+  for (let i = 0; i < graphAdapter.n; i++) order[i] = i;
+
+  const strategyCode: CandidateStrategyCode = options.candidateStrategyCode;
+  let improved: boolean = true;
+  let localPasses: number = 0;
+  while (improved) {
+    improved = false;
+    localPasses++;
+    shuffleArrayInPlace(order, random);
+    for (let idx = 0; idx < order.length; idx++) {
+      const nodeIndex: number = order[idx]!;
+      if (fixedNodeMask?.[nodeIndex]) continue;
+      const candidateCount: number = partition.accumulateNeighborCommunityEdgeWeights(nodeIndex);
+      const { bestCommunityId, bestGain } = findBestCommunityMove(
+        partition,
+        graphAdapter,
+        nodeIndex,
+        candidateCount,
+        strategyCode,
+        options,
+        random,
+      );
+      if (bestCommunityId !== partition.nodeCommunity[nodeIndex]! && bestGain > GAIN_EPSILON) {
+        partition.moveNodeToCommunity(nodeIndex, bestCommunityId);
+        improved = true;
+      }
+    }
+    if (localPasses >= options.maxLocalPasses) break;
+  }
+}
+
+/**
+ * Compose the running `originalToCurrent` mapping with this level's
+ * fine→coarse community labels, in place.
+ */
+function applyFineToCoarseMapping(originalToCurrent: Int32Array, fineToCoarse: Int32Array): void {
+  for (let i = 0; i < originalToCurrent.length; i++) {
+    originalToCurrent[i] = fineToCoarse[originalToCurrent[i]!]!;
+  }
+}
+
 /**
  * Evaluate all candidate communities for a node and return the best move.
  * Encapsulates the four candidate-selection strategies (All, RandomAny,