graphbox 1.2.1 → 1.3.0

package/dist/algorithms/traversal/overlap-based/strategies/between-graph/between-graph-strategy.d.ts

@@ -0,0 +1,42 @@
+import { OverlapBasedExpansionResult } from '../../overlap-result.js';
+/**
+ * Strategy for defining the "between-graph" subgraph after termination.
+ *
+ * Once overlap-based termination occurs, this strategy determines what
+ * constitutes the output subgraph that will be passed to Path Salience ranking.
+ *
+ * The goal is to produce a subgraph that:
+ * - Contains paths between all seed pairs (if N ≥ 2)
+ * - Preserves topological structure for accurate MI computation
+ * - Maintains statistical properties needed for salient ranking
+ */
+export interface BetweenGraphStrategy {
+    /**
+     * Strategy identifier for naming SUT variants.
+     */
+    readonly id: string;
+    /**
+     * Extract the between-graph subgraph from expansion results.
+     *
+     * @param expansionResult - Raw expansion output with all visited nodes/edges
+     * @param graph - Original graph (optional, for shortest paths or MI computation)
+     * @returns Refined subgraph definition with nodes, edges, and paths
+     */
+    extractBetweenGraph(expansionResult: OverlapBasedExpansionResult, graph?: unknown): BetweenGraphOutput;
+}
+/**
+ * Output from BetweenGraphStrategy defining the between-graph subgraph.
+ */
+export interface BetweenGraphOutput {
+    /** Nodes included in the between-graph subgraph */
+    nodes: Set<string>;
+    /** Edges included in the between-graph subgraph */
+    edges: Set<string>;
+    /** Paths preserved in the subgraph (fromSeed → toSeed → node array) */
+    paths: Array<{
+        fromSeed: number;
+        toSeed: number;
+        nodes: string[];
+    }>;
+}
+//# sourceMappingURL=between-graph-strategy.d.ts.map

package/dist/algorithms/traversal/overlap-based/strategies/between-graph/between-graph-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"between-graph-strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/algorithms/traversal/overlap-based/strategies/between-graph/between-graph-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAE3E;;;;;;;;;;GAUG;AACH,MAAM,WAAW,oBAAoB;IACpC;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;;;;;OAMG;IACH,mBAAmB,CAClB,eAAe,EAAE,2BAA2B,EAC5C,KAAK,CAAC,EAAE,OAAO,GACb,kBAAkB,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC,mDAAmD;IACnD,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAEnB,mDAAmD;IACnD,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAEnB,uEAAuE;IACvE,KAAK,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CACpE"}

package/dist/algorithms/traversal/overlap-based/strategies/between-graph/minimal-paths.strategy.d.ts

@@ -0,0 +1,41 @@
+import { OverlapBasedExpansionResult } from '../../overlap-result.js';
+import { BetweenGraphStrategy } from './between-graph-strategy.js';
+/**
+ * Minimal Paths Between-Graph Strategy
+ *
+ * Returns the minimal subgraph containing only the nodes and edges that appear
+ * in the discovered paths. This produces the most compact between-graph representation.
+ *
+ * **Algorithm**: Extract all nodes and edges that appear in any discovered path,
+ * excluding nodes visited but not part of path connections.
+ *
+ * **Complexity**: O(P × L) where P = number of paths, L = average path length
+ *
+ * **Thesis Alignment**: This strategy provides the most compact representation
+ * of the between-graph, useful for memory-constrained scenarios and as a baseline
+ * for comparison with more comprehensive strategies.
+ */
+export declare class MinimalPathsStrategy implements BetweenGraphStrategy {
+    /** Strategy identifier for naming SUT variants */
+    readonly id = "minimal-paths";
+    /**
+     * Extract the between-graph subgraph from expansion results.
+     *
+     * Returns only nodes and edges that appear in discovered paths.
+     * For N=1 (no paths), returns all visited nodes as fallback.
+     *
+     * @param expansionResult - Raw expansion output with all visited nodes/edges
+     * @param _graph - Original graph (unused for minimal paths)
+     * @returns Refined subgraph definition with nodes, edges, and paths
+     */
+    extractBetweenGraph(expansionResult: OverlapBasedExpansionResult, _graph?: unknown): {
+        nodes: Set<string>;
+        edges: Set<string>;
+        paths: Array<{
+            fromSeed: number;
+            toSeed: number;
+            nodes: string[];
+        }>;
+    };
+}
+//# sourceMappingURL=minimal-paths.strategy.d.ts.map

package/dist/algorithms/traversal/overlap-based/strategies/between-graph/minimal-paths.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimal-paths.strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/algorithms/traversal/overlap-based/strategies/between-graph/minimal-paths.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE;;;;;;;;;;;;;;GAcG;AACH,qBAAa,oBAAqB,YAAW,oBAAoB;IAChE,kDAAkD;IAClD,QAAQ,CAAC,EAAE,mBAAmB;IAE9B;;;;;;;;;OASG;IACH,mBAAmB,CAClB,eAAe,EAAE,2BAA2B,EAC5C,MAAM,CAAC,EAAE,OAAO,GACd;QACF,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QACnB,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QACnB,KAAK,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAC;KACpE;CAiCD"}

package/dist/algorithms/traversal/overlap-based/strategies/between-graph/salience-preserving.strategy.d.ts

@@ -0,0 +1,82 @@
+import { OverlapBasedExpansionResult } from '../../overlap-result.js';
+import { BetweenGraphStrategy } from './between-graph-strategy.js';
+/**
+ * Configuration for SaliencePreservingStrategy.
+ */
+export interface SaliencePreservingConfig {
+    /**
+     * Target percentage of nodes to preserve based on salience ranking.
+     * Range: (0, 100]
+     * Default: 100 (preserve all salient nodes, equivalent to full expansion result)
+     */
+    targetPreservation?: number;
+    /**
+     * Minimum number of nodes to preserve regardless of salience.
+     * Default: 10 (ensures basic connectivity)
+     */
+    minNodes?: number;
+}
+/**
+ * Salience-Preserving Between-Graph Strategy
+ *
+ * Preserves nodes and edges based on their contribution to path salience
+ * (mutual information). This strategy aims to retain high-information paths
+ * while discarding low-contributing regions.
+ *
+ * **Algorithm**: Rank nodes by their occurrence frequency in discovered paths
+ * (as a proxy for MI contribution), then preserve nodes/edges above a threshold.
+ *
+ * **Complexity**: O(P × L + V log V) where P = paths, L = avg length, V = nodes
+ *
+ * **Thesis Alignment**: This strategy implements the thesis concept of
+ * salience-based subgraph extraction, preserving paths that maximize mutual
+ * information for downstream ranking tasks.
+ *
+ * **Note**: This is a simplified implementation using path frequency as a
+ * proxy for MI. A full implementation would integrate with Path Salience
+ * ranking to compute actual MI scores.
+ */
+export declare class SaliencePreservingStrategy implements BetweenGraphStrategy {
+    /** Strategy identifier for naming SUT variants */
+    readonly id = "salience-preserving";
+    /** Target percentage of nodes to preserve */
+    private readonly targetPreservation;
+    /** Minimum number of nodes to preserve */
+    private readonly minNodes;
+    /**
+     * Create a SaliencePreserving strategy.
+     *
+     * @param config - Strategy configuration
+     */
+    constructor(config?: SaliencePreservingConfig);
+    /**
+     * Extract the between-graph subgraph from expansion results.
+     *
+     * Preserves nodes based on path salience ranking.
+     *
+     * @param expansionResult - Raw expansion output with all visited nodes/edges
+     * @param _graph - Original graph (unused, we use path-based salience)
+     * @returns Refined subgraph definition with nodes, edges, and paths
+     */
+    extractBetweenGraph(expansionResult: OverlapBasedExpansionResult, _graph?: unknown): {
+        nodes: Set<string>;
+        edges: Set<string>;
+        paths: Array<{
+            fromSeed: number;
+            toSeed: number;
+            nodes: string[];
+        }>;
+    };
+    /**
+     * Calculate node salience based on path occurrence frequency.
+     *
+     * Nodes that appear in more paths have higher salience scores.
+     * This is a simplified proxy for mutual information contribution.
+     *
+     * @param paths - Discovered paths from expansion
+     * @returns Map of node ID to salience score
+     * @private
+     */
+    private calculateNodeSalience;
+}
+//# sourceMappingURL=salience-preserving.strategy.d.ts.map

package/dist/algorithms/traversal/overlap-based/strategies/between-graph/salience-preserving.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"salience-preserving.strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/algorithms/traversal/overlap-based/strategies/between-graph/salience-preserving.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,0BAA2B,YAAW,oBAAoB;IACtE,kDAAkD;IAClD,QAAQ,CAAC,EAAE,yBAAyB;IAEpC,6CAA6C;IAC7C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAE5C,0CAA0C;IAC1C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC;;;;OAIG;gBACS,MAAM,GAAE,wBAA6B;IAKjD;;;;;;;;OAQG;IACH,mBAAmB,CAClB,eAAe,EAAE,2BAA2B,EAC5C,MAAM,CAAC,EAAE,OAAO,GACd;QACF,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QACnB,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QACnB,KAAK,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAC;KACpE;IA2DD;;;;;;;;;OASG;IACH,OAAO,CAAC,qBAAqB;CAc7B"}

package/dist/algorithms/traversal/overlap-based/strategies/between-graph/truncated-component.strategy.d.ts

@@ -0,0 +1,59 @@
+import { OverlapBasedExpansionResult } from '../../overlap-result.js';
+import { BetweenGraphStrategy } from './between-graph-strategy.js';
+/**
+ * Truncated Component Between-Graph Strategy
+ *
+ * Returns the connected component(s) containing the overlap nodes where
+ * frontiers met. This preserves more context than MinimalPaths while
+ * avoiding fringe regions that don't contribute to seed connectivity.
+ *
+ * **Algorithm**: Identify all overlap meeting nodes, then extract the
+ * connected component(s) containing these nodes using BFS/DFS traversal.
+ *
+ * **Complexity**: O(V + E) where V = visited nodes, E = visited edges
+ *
+ * **Thesis Alignment**: This strategy provides a balanced approach that
+ * preserves the neighborhood structure around overlap regions while excluding
+ * peripheral exploration that doesn't contribute to seed connectivity.
+ */
+export declare class TruncatedComponentStrategy implements BetweenGraphStrategy {
+    /** Strategy identifier for naming SUT variants */
+    readonly id = "truncated-component";
+    /**
+     * Extract the between-graph subgraph from expansion results.
+     *
+     * Returns the connected component containing overlap meeting nodes.
+     *
+     * @param expansionResult - Raw expansion output with all visited nodes/edges
+     * @param _graph - Original graph (unused, we use sampled data)
+     * @returns Refined subgraph definition with nodes, edges, and paths
+     */
+    extractBetweenGraph(expansionResult: OverlapBasedExpansionResult, _graph?: unknown): {
+        nodes: Set<string>;
+        edges: Set<string>;
+        paths: Array<{
+            fromSeed: number;
+            toSeed: number;
+            nodes: string[];
+        }>;
+    };
+    /**
+     * Build an adjacency list from sampled edges.
+     *
+     * @param expansionResult - Expansion result with sampled edges
+     * @returns Adjacency list (node -> set of neighbors)
+     * @private
+     */
+    private buildAdjacencyList;
+    /**
+     * Perform BFS to find the connected component containing a start node.
+     *
+     * @param startNode - Node to start BFS from
+     * @param adj - Adjacency list
+     * @param componentNodes - Set to accumulate component nodes
+     * @param componentEdges - Set to accumulate component edges
+     * @private
+     */
+    private bfsComponent;
+}
+//# sourceMappingURL=truncated-component.strategy.d.ts.map

package/dist/algorithms/traversal/overlap-based/strategies/between-graph/truncated-component.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncated-component.strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/algorithms/traversal/overlap-based/strategies/between-graph/truncated-component.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,0BAA2B,YAAW,oBAAoB;IACtE,kDAAkD;IAClD,QAAQ,CAAC,EAAE,yBAAyB;IAEpC;;;;;;;;OAQG;IACH,mBAAmB,CAClB,eAAe,EAAE,2BAA2B,EAC5C,MAAM,CAAC,EAAE,OAAO,GACd;QACF,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QACnB,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QACnB,KAAK,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAC;KACpE;IAwCD;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IA4B1B;;;;;;;;OAQG;IACH,OAAO,CAAC,YAAY;CAsCpB"}

package/dist/algorithms/traversal/overlap-based/strategies/n1-handling/coverage-threshold.strategy.d.ts

@@ -0,0 +1,57 @@
+import { FrontierState } from '../../frontier-state.js';
+import { N1HandlingStrategy } from './n1-handling-strategy.js';
+/**
+ * Configuration for CoverageThresholdStrategy.
+ */
+export interface CoverageThresholdConfig {
+    /**
+     * Coverage percentage threshold for termination (0-100).
+     * Default: 80 (terminate when 80% of graph is visited)
+     */
+    coverageThreshold?: number;
+    /**
+     * Minimum iterations before allowing coverage-based termination.
+     * Default: 10 (prevents premature termination on tiny graphs)
+     */
+    minIterations?: number;
+}
+/**
+ * Coverage Threshold N=1 Handling Strategy
+ *
+ * Terminates single-seed expansion when a percentage of the graph has been visited.
+ * This provides a principled stopping criterion for the N=1 case where overlap
+ * with other seeds is impossible.
+ *
+ * **Algorithm**: Terminate when (visited_nodes / total_nodes) >= threshold,
+ * subject to a minimum iteration count to prevent premature termination.
+ *
+ * **Complexity**: O(1) per iteration check
+ *
+ * **Thesis Alignment**: This strategy provides a coverage-based termination
+ * criterion for ego-network sampling, ensuring sufficient exploration while
+ * avoiding exhaustive traversal of large graphs.
+ */
+export declare class CoverageThresholdStrategy implements N1HandlingStrategy {
+    /** Strategy identifier for naming SUT variants */
+    readonly id = "coverage-threshold";
+    /** Coverage percentage threshold (0-100) */
+    private readonly threshold;
+    /** Minimum iterations before termination allowed */
+    private readonly minIterations;
+    /**
+     * Create a CoverageThreshold strategy.
+     *
+     * @param config - Strategy configuration
+     */
+    constructor(config?: CoverageThresholdConfig);
+    /**
+     * Check if single-seed expansion should terminate.
+     *
+     * @param frontier - The sole frontier's state
+     * @param totalNodes - Total nodes in graph (for coverage calculation)
+     * @param iteration - Current iteration count
+     * @returns true if should terminate
+     */
+    shouldTerminate(frontier: FrontierState, totalNodes?: number, iteration?: number): boolean;
+}
+//# sourceMappingURL=coverage-threshold.strategy.d.ts.map

package/dist/algorithms/traversal/overlap-based/strategies/n1-handling/coverage-threshold.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage-threshold.strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/algorithms/traversal/overlap-based/strategies/n1-handling/coverage-threshold.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACvC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,yBAA0B,YAAW,kBAAkB;IACnE,kDAAkD;IAClD,QAAQ,CAAC,EAAE,wBAAwB;IAEnC,4CAA4C;IAC5C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC,oDAAoD;IACpD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IAEvC;;;;OAIG;gBACS,MAAM,GAAE,uBAA4B;IAKhD;;;;;;;OAOG;IACH,eAAe,CACd,QAAQ,EAAE,aAAa,EACvB,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GAChB,OAAO;CAkBV"}

package/dist/algorithms/traversal/overlap-based/strategies/n1-handling/n1-handling-strategy.d.ts

@@ -0,0 +1,25 @@
+import { FrontierState } from '../../frontier-state.js';
+/**
+ * Strategy for handling N=1 (single seed) scenario where overlap is impossible.
+ *
+ * When N=1, there are no other seeds to overlap with. This strategy provides
+ * alternative termination criteria (e.g., coverage threshold).
+ *
+ * @template TFrontier - Type of frontier state (for type safety)
+ */
+export interface N1HandlingStrategy {
+    /**
+     * Strategy identifier for naming SUT variants.
+     */
+    readonly id: string;
+    /**
+     * Check if single-seed expansion should terminate.
+     *
+     * @param frontier - The sole frontier's state
+     * @param totalNodes - Total nodes in graph (for coverage calculation, if available)
+     * @param iteration - Current iteration count
+     * @returns true if should terminate
+     */
+    shouldTerminate(frontier: FrontierState, totalNodes?: number, iteration?: number): boolean;
+}
+//# sourceMappingURL=n1-handling-strategy.d.ts.map

package/dist/algorithms/traversal/overlap-based/strategies/n1-handling/n1-handling-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"n1-handling-strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/algorithms/traversal/overlap-based/strategies/n1-handling/n1-handling-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IAClC;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;;;;;;OAOG;IACH,eAAe,CACd,QAAQ,EAAE,aAAa,EACvB,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;CACX"}

package/dist/algorithms/traversal/overlap-based/strategies/overlap-detection/overlap-detection-strategy.d.ts

@@ -0,0 +1,26 @@
+import { FrontierState } from '../../frontier-state.js';
+/**
+ * Strategy for detecting overlap between seed search regions during expansion.
+ *
+ * Called during node expansion to determine if a newly discovered node
+ * represents an overlap event that should be tracked.
+ *
+ * @template TFrontier - Type of frontier state (for type safety)
+ */
+export interface OverlapDetectionStrategy {
+    /**
+     * Strategy identifier for naming SUT variants.
+     */
+    readonly id: string;
+    /**
+     * Check if adding this node creates overlap with other frontiers.
+     *
+     * @param targetId - Node being added to active frontier
+     * @param activeFrontier - The frontier that is expanding
+     * @param allFrontiers - All frontiers in the expansion
+     * @param nodeToFrontierIndex - O(1) map tracking which frontier owns each node
+     * @returns Array of frontier indices that overlap with active frontier
+     */
+    detectOverlap(targetId: string, activeFrontier: FrontierState, allFrontiers: FrontierState[], nodeToFrontierIndex: Map<string, number>): number[];
+}
+//# sourceMappingURL=overlap-detection-strategy.d.ts.map

package/dist/algorithms/traversal/overlap-based/strategies/overlap-detection/overlap-detection-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlap-detection-strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/algorithms/traversal/overlap-based/strategies/overlap-detection/overlap-detection-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;;;;;;GAOG;AACH,MAAM,WAAW,wBAAwB;IACxC;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;;;;;;;OAQG;IACH,aAAa,CACZ,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,aAAa,EAC7B,YAAY,EAAE,aAAa,EAAE,EAC7B,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACtC,MAAM,EAAE,CAAC;CACZ"}

package/dist/algorithms/traversal/overlap-based/strategies/overlap-detection/physical-meeting.strategy.d.ts

@@ -0,0 +1,35 @@
+import { FrontierState } from '../../frontier-state.js';
+import { OverlapDetectionStrategy } from './overlap-detection-strategy.js';
+/**
+ * Physical Meeting Overlap Detection Strategy
+ *
+ * Detects overlap when two frontiers physically visit the same node.
+ * This is the O(1) overlap detection method used in DegreePrioritisedExpansion,
+ * which tracks which frontier owns each node via a `nodeToFrontierIndex` Map.
+ *
+ * **Algorithm**: When adding a node to the active frontier, check if another
+ * frontier already owns it via O(1) Map lookup. If so, return that frontier's index.
+ *
+ * **Complexity**: O(1) per node added
+ *
+ * **Thesis Alignment**: This is the original overlap detection method from
+ * DegreePrioritisedExpansion, providing the baseline for comparison with
+ * more sophisticated strategies.
+ */
+export declare class PhysicalMeetingStrategy implements OverlapDetectionStrategy {
+    /** Strategy identifier for naming SUT variants */
+    readonly id = "physical-meeting";
+    /**
+     * Check if adding this node creates overlap with other frontiers.
+     *
+     * Uses O(1) Map lookup to check if another frontier already visited this node.
+     *
+     * @param targetId - Node being added to active frontier
+     * @param activeFrontier - The frontier that is expanding
+     * @param _allFrontiers - All frontiers in the expansion (unused)
+     * @param nodeToFrontierIndex - O(1) map tracking which frontier owns each node
+     * @returns Array of frontier indices that overlap with active frontier
+     */
+    detectOverlap(targetId: string, activeFrontier: FrontierState, _allFrontiers: FrontierState[], nodeToFrontierIndex: Map<string, number>): number[];
+}
+//# sourceMappingURL=physical-meeting.strategy.d.ts.map

package/dist/algorithms/traversal/overlap-based/strategies/overlap-detection/physical-meeting.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"physical-meeting.strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/algorithms/traversal/overlap-based/strategies/overlap-detection/physical-meeting.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAEhF;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,uBAAwB,YAAW,wBAAwB;IACvE,kDAAkD;IAClD,QAAQ,CAAC,EAAE,sBAAsB;IAEjC;;;;;;;;;;OAUG;IACH,aAAa,CACZ,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,aAAa,EAC7B,aAAa,EAAE,aAAa,EAAE,EAC9B,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACtC,MAAM,EAAE;CAUX"}

package/dist/algorithms/traversal/overlap-based/strategies/overlap-detection/sphere-intersection.strategy.d.ts

@@ -0,0 +1,69 @@
+import { FrontierState } from '../../frontier-state.js';
+import { OverlapDetectionStrategy } from './overlap-detection-strategy.js';
+/**
+ * Configuration for SphereIntersectionStrategy.
+ */
+export interface SphereIntersectionConfig {
+    /**
+     * Maximum distance from seed for overlap detection.
+     * Default: Infinity (no limit)
+     */
+    maxDistance?: number;
+}
+/**
+ * Sphere Intersection Overlap Detection Strategy
+ *
+ * Detects overlap when a node falls within another frontier's search radius.
+ * This strategy models each frontier as an N-dimensional sphere expanding
+ * from its seed, where radius = maximum distance of any visited node.
+ *
+ * **Algorithm**: Track the distance from seed for each visited node. When
+ * adding a node, check if its distance from the active frontier's seed is
+ * within another frontier's current radius:
+ *
+ * ```
+ * overlap if: distance(targetId, seedA) <= radius_of_frontier_B
+ * ```
+ *
+ * **Complexity**: O(N) per node added where N = number of frontiers
+ *
+ * **Thesis Alignment**: This strategy models the geometric intuition of
+ * "search regions meeting" in N-dimensional space, providing early
+ * termination based on spatial proximity rather than physical node sharing.
+ */
+export declare class SphereIntersectionStrategy implements OverlapDetectionStrategy {
+    /** Strategy identifier for naming SUT variants */
+    readonly id = "sphere-intersection";
+    /** Maximum distance for overlap detection */
+    private readonly maxDistance;
+    /**
+     * Create a SphereIntersection strategy.
+     *
+     * @param config - Strategy configuration
+     */
+    constructor(config?: SphereIntersectionConfig);
+    /**
+     * Check if adding this node creates overlap with other frontiers.
+     *
+     * Checks if the node's distance from the active seed is within any
+     * other frontier's current radius.
+     *
+     * @param targetId - Node being added to active frontier
+     * @param activeFrontier - The frontier that is expanding
+     * @param allFrontiers - All frontiers in the expansion
+     * @param _nodeToFrontierIndex - O(1) map (unused, we use distance tracking)
+     * @returns Array of frontier indices that overlap with active frontier
+     */
+    detectOverlap(targetId: string, activeFrontier: FrontierState, allFrontiers: FrontierState[], _nodeToFrontierIndex: Map<string, number>): number[];
+    /**
+     * Calculate the current radius of a frontier.
+     *
+     * Radius = maximum distance of any visited node from the seed.
+     *
+     * @param nodeDistances - Map of node IDs to distances from seed
+     * @returns Current frontier radius
+     * @private
+     */
+    private calculateFrontierRadius;
+}
+//# sourceMappingURL=sphere-intersection.strategy.d.ts.map

package/dist/algorithms/traversal/overlap-based/strategies/overlap-detection/sphere-intersection.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sphere-intersection.strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/algorithms/traversal/overlap-based/strategies/overlap-detection/sphere-intersection.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,0BAA2B,YAAW,wBAAwB;IAC1E,kDAAkD;IAClD,QAAQ,CAAC,EAAE,yBAAyB;IAEpC,6CAA6C;IAC7C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IAErC;;;;OAIG;gBACS,MAAM,GAAE,wBAA6B;IAIjD;;;;;;;;;;;OAWG;IACH,aAAa,CACZ,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,aAAa,EAC7B,YAAY,EAAE,aAAa,EAAE,EAC7B,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACvC,MAAM,EAAE;IA2BX;;;;;;;;OAQG;IACH,OAAO,CAAC,uBAAuB;CAS/B"}

package/dist/algorithms/traversal/overlap-based/strategies/overlap-detection/threshold-sharing.strategy.d.ts

@@ -0,0 +1,72 @@
+import { FrontierState } from '../../frontier-state.js';
+import { OverlapDetectionStrategy } from './overlap-detection-strategy.js';
+/**
+ * Configuration for ThresholdSharingStrategy.
+ */
+export interface ThresholdSharingConfig {
+    /**
+     * Minimum Jaccard similarity threshold to consider frontiers as overlapping.
+     * Range: [0, 1] where 0 = no overlap, 1 = identical sets
+     * Default: 0.5 (50% overlap)
+     */
+    threshold?: number;
+}
+/**
+ * Threshold Sharing Overlap Detection Strategy
+ *
+ * Detects overlap when the Jaccard similarity between two frontiers' visited
+ * sets exceeds a threshold. Jaccard similarity measures the ratio of shared
+ * nodes to the union of visited nodes.
+ *
+ * **Algorithm**: Calculate Jaccard similarity between the active frontier's
+ * visited set and each other frontier's visited set:
+ *
+ * ```
+ * J(A,B) = |A ∩ B| / |A ∪ B|
+ * ```
+ *
+ * Return all other frontiers where J(active, other) >= threshold.
+ *
+ * **Complexity**: O(N × V) where N = number of frontiers, V = visited set sizes
+ *
+ * **Thesis Alignment**: This strategy detects "soft" overlap before physical
+ * meeting occurs, potentially enabling earlier termination at the cost of
+ * additional computation per node added.
+ */
+export declare class ThresholdSharingStrategy implements OverlapDetectionStrategy {
+    /** Strategy identifier for naming SUT variants */
+    readonly id = "threshold-sharing";
+    /** Minimum similarity threshold (default 0.5) */
+    private readonly threshold;
+    /**
+     * Create a ThresholdSharing strategy.
+     *
+     * @param config - Strategy configuration
+     */
+    constructor(config?: ThresholdSharingConfig);
+    /**
+     * Check if adding this node creates overlap with other frontiers.
+     *
+     * Calculates Jaccard similarity between the active frontier's visited set
+     * (including the new node) and each other frontier's visited set.
+     *
+     * @param targetId - Node being added to active frontier
+     * @param activeFrontier - The frontier that is expanding
+     * @param allFrontiers - All frontiers in the expansion
+     * @param _nodeToFrontierIndex - O(1) map (unused, we use set operations)
+     * @returns Array of frontier indices that overlap with active frontier
+     */
+    detectOverlap(targetId: string, activeFrontier: FrontierState, allFrontiers: FrontierState[], _nodeToFrontierIndex: Map<string, number>): number[];
+    /**
+     * Calculate Jaccard similarity between two sets.
+     *
+     * J(A,B) = |A ∩ B| / |A ∪ B|
+     *
+     * @param setA - First set
+     * @param setB - Second set
+     * @returns Jaccard similarity coefficient [0, 1]
+     * @private
+     */
+    private calculateJaccardSimilarity;
+}
+//# sourceMappingURL=threshold-sharing.strategy.d.ts.map

package/dist/algorithms/traversal/overlap-based/strategies/overlap-detection/threshold-sharing.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threshold-sharing.strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/algorithms/traversal/overlap-based/strategies/overlap-detection/threshold-sharing.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,wBAAyB,YAAW,wBAAwB;IACxE,kDAAkD;IAClD,QAAQ,CAAC,EAAE,uBAAuB;IAElC,iDAAiD;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC;;;;OAIG;gBACS,MAAM,GAAE,sBAA2B;IAI/C;;;;;;;;;;;OAWG;IACH,aAAa,CACZ,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,aAAa,EAC7B,YAAY,EAAE,aAAa,EAAE,EAC7B,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACvC,MAAM,EAAE;IAwBX;;;;;;;;;OASG;IACH,OAAO,CAAC,0BAA0B;CAiBlC"}

package/dist/algorithms/traversal/overlap-based/strategies/termination/common-convergence.strategy.d.ts

@@ -0,0 +1,45 @@
+import { FrontierState } from '../../frontier-state.js';
+import { TerminationStrategy } from './termination-strategy.js';
+/**
+ * Common Convergence Termination Strategy
+ *
+ * Terminates expansion when all seeds share at least one common visited node.
+ * This is the weakest termination condition, allowing termination as soon as
+ * a single node is reached by all frontiers.
+ *
+ * **Algorithm**: Track the intersection of all visited sets. Terminate when
+ * the intersection is non-empty (at least one node visited by all frontiers).
+ *
+ * **Complexity**: O(N × V) where N = number of seeds, V = visited set sizes
+ *
+ * **Thesis Alignment**: This strategy provides the earliest possible termination
+ * for connected seed regions, making it suitable for time-constrained scenarios
+ * where any convergent path is sufficient.
+ */
+export declare class CommonConvergenceStrategy implements TerminationStrategy {
+    /** Strategy identifier for naming SUT variants */
+    readonly id = "common-convergence";
+    /**
+     * Check if expansion should terminate based on current state.
+     *
+     * @param allFrontiers - All frontiers in the expansion
+     * @param _overlapEvents - All recorded overlap events (unused, we use visited sets directly)
+     * @param _iteration - Current iteration count (unused)
+     * @returns true if expansion should terminate
+     */
+    shouldTerminate(allFrontiers: FrontierState[], _overlapEvents: readonly {
+        frontierA: number;
+        frontierB: number;
+    }[], _iteration: number): boolean;
+    /**
+     * Find nodes that are visited by all frontiers.
+     *
+     * Computes the intersection of all visited sets.
+     *
+     * @param allFrontiers - All frontiers in the expansion
+     * @returns Set of nodes visited by all frontiers
+     * @private
+     */
+    private findCommonVisitedNodes;
+}
+//# sourceMappingURL=common-convergence.strategy.d.ts.map

package/dist/algorithms/traversal/overlap-based/strategies/termination/common-convergence.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-convergence.strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/algorithms/traversal/overlap-based/strategies/termination/common-convergence.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,yBAA0B,YAAW,mBAAmB;IACpE,kDAAkD;IAClD,QAAQ,CAAC,EAAE,wBAAwB;IAEnC;;;;;;;OAOG;IACH,eAAe,CACd,YAAY,EAAE,aAAa,EAAE,EAC7B,cAAc,EAAE,SAAS;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,EAAE,EACnE,UAAU,EAAE,MAAM,GAChB,OAAO;IAeV;;;;;;;;OAQG;IACH,OAAO,CAAC,sBAAsB;CA2B9B"}

package/dist/algorithms/traversal/overlap-based/strategies/termination/full-pairwise.strategy.d.ts

@@ -0,0 +1,43 @@
+import { FrontierState } from '../../frontier-state.js';
+import { TerminationStrategy } from './termination-strategy.js';
+/**
+ * Full Pairwise Termination Strategy
+ *
+ * Terminates expansion when every seed pair has achieved overlap.
+ * This is the strictest termination condition, requiring C(N,2) pairwise overlaps.
+ *
+ * **Algorithm**: Build an overlap graph where nodes = frontiers and edges = overlaps.
+ * Terminate when the overlap graph is complete (all possible edges exist).
+ *
+ * **Complexity**: O(N²) where N = number of seeds (frontiers)
+ *
+ * **Thesis Alignment**: This strategy ensures maximum connectivity between all
+ * seed regions, providing the strongest guarantee of a well-sampled between-graph
+ * at the cost of potentially longer execution time.
+ */
+export declare class FullPairwiseStrategy implements TerminationStrategy {
+    /** Strategy identifier for naming SUT variants */
+    readonly id = "full-pairwise";
+    /**
+     * Check if expansion should terminate based on current state.
+     *
+     * @param allFrontiers - All frontiers in the expansion
+     * @param overlapEvents - All recorded overlap events so far
+     * @param _iteration - Current iteration count (unused)
+     * @returns true if expansion should terminate
+     */
+    shouldTerminate(allFrontiers: FrontierState[], overlapEvents: readonly {
+        frontierA: number;
+        frontierB: number;
+    }[], _iteration: number): boolean;
+    /**
+     * Get a canonical key for a pair of frontier indices.
+     *
+     * @param a - First frontier index
+     * @param b - Second frontier index
+     * @returns Canonical pair key (sorted)
+     * @private
+     */
+    private getPairKey;
+}
+//# sourceMappingURL=full-pairwise.strategy.d.ts.map