graphbox 1.2.2 → 1.3.0

package/dist/experiments/baselines/ensemble-expansion.d.ts

@@ -0,0 +1,123 @@
+import { GraphExpander } from '../../interfaces/graph-expander';
+/**
+ * Result from ensemble expansion.
+ */
+export interface EnsembleExpansionResult {
+    /** Discovered paths (enumerated through union subgraph) */
+    paths: Array<{
+        fromSeed: number;
+        toSeed: number;
+        nodes: string[];
+    }>;
+    /** Union of all nodes visited by all strategies */
+    sampledNodes: Set<string>;
+    /** Set of edges visited during expansion */
+    sampledEdges: Set<string>;
+    /** Per-strategy sampled nodes (for diagnostics) */
+    sampledNodesPerStrategy: Map<string, Set<string>>;
+    /** Statistics about the expansion */
+    stats: EnsembleExpansionStats;
+    /** Map from node ID to the iteration when it was first discovered (across all strategies) */
+    nodeDiscoveryIteration: Map<string, number>;
+}
+/**
+ * Statistics collected during ensemble expansion.
+ */
+export interface EnsembleExpansionStats {
+    /** Total nodes in union across all strategies */
+    totalUnionNodes: number;
+    /** Breakdown of node counts per strategy */
+    nodesPerStrategy: Map<string, number>;
+    /** Overlap statistics between strategies */
+    strategyOverlap: Map<string, number>;
+    /** Total paths enumerated through union */
+    totalPaths: number;
+}
+/**
+ * Ensemble Expansion (Union of BFS, DFS, Degree-Priority)
+ *
+ * Baseline algorithm that combines results from three different expansion
+ * strategies: standard BFS, depth-first search (DFS), and degree-prioritised.
+ * Enumerates all paths through the union of discovered subgraphs.
+ *
+ * **Key Properties**:
+ * - Runs BFS, DFS, and degree-priority expansion independently
+ * - Computes union of all visited nodes across strategies
+ * - Enumerates ALL simple paths through union subgraph
+ * - Terminates when all strategies complete
+ *
+ * **Experimental Purpose**:
+ * Tests whether combining multiple exploration strategies provides better
+ * coverage and path diversity than any single strategy alone. If ensemble
+ * outperforms degree-prioritised, strategy diversity matters. If not,
+ * a single well-chosen strategy suffices.
+ *
+ * **Note**: Path enumeration through large unions can be expensive.
+ * Consider depth limits for tractability.
+ *
+ * @template T - Type of node data returned by expander
+ */
+export declare class EnsembleExpansion<T> {
+    private readonly expander;
+    private readonly seeds;
+    private readonly sampledEdges;
+    private readonly nodeDiscoveryIteration;
+    private stats;
+    /**
+     * Create a new ensemble expansion.
+     *
+     * @param expander - Graph expander providing neighbour access
+     * @param seeds - Array of seed node IDs (N >= 1)
+     * @throws Error if no seeds provided
+     */
+    constructor(expander: GraphExpander<T>, seeds: readonly string[]);
+    /**
+     * Run the ensemble expansion to completion.
+     *
+     * Executes BFS, DFS, and degree-priority strategies in sequence,
+     * then enumerates paths through the union.
+     *
+     * @returns Ensemble results including paths and union subgraph
+     */
+    run(): Promise<EnsembleExpansionResult>;
+    /**
+     * Run standard BFS expansion.
+     * @returns Set of visited nodes
+     * @internal
+     */
+    private runBfs;
+    /**
+     * Run depth-first search expansion.
+     * @returns Set of visited nodes
+     * @internal
+     */
+    private runDfs;
+    /**
+     * Run degree-prioritised expansion.
+     * @returns Set of visited nodes
+     * @internal
+     */
+    private runDegreePriority;
+    /**
+     * Enumerate all simple paths through the union subgraph.
+     * Uses DFS with backtracking to find all paths between seed pairs.
+     *
+     * @param nodes - Union of nodes from all strategies
+     * @returns Array of paths between all seed pairs
+     * @internal
+     */
+    private enumeratePathsThroughUnion;
+    /**
+     * Find all simple paths between two nodes within the sampled subgraph.
+     * Uses DFS with backtracking and depth limit for tractability.
+     *
+     * @param start - Start node ID
+     * @param end - End node ID
+     * @param allowedNodes - Set of nodes in the sampled subgraph
+     * @param maxDepth - Maximum path length to explore
+     * @returns Array of simple paths (each path is array of node IDs)
+     * @internal
+     */
+    private findAllSimplePaths;
+}
+//# sourceMappingURL=ensemble-expansion.d.ts.map

package/dist/experiments/baselines/ensemble-expansion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensemble-expansion.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/ensemble-expansion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACvC,2DAA2D;IAC3D,KAAK,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAEpE,mDAAmD;IACnD,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,4CAA4C;IAC5C,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,mDAAmD;IACnD,uBAAuB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAElD,qCAAqC;IACrC,KAAK,EAAE,sBAAsB,CAAC;IAE9B,6FAA6F;IAC7F,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,iDAAiD;IACjD,eAAe,EAAE,MAAM,CAAC;IAExB,4CAA4C;IAC5C,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEtC,4CAA4C;IAC5C,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAErC,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;CACnB;AAmCD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,iBAAiB,CAAC,CAAC;IAa9B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAbvB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAClD,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAA6B;IACpE,OAAO,CAAC,KAAK,CAAyB;IAEtC;;;;;;OAMG;gBAEe,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE;IAc1C;;;;;;;OAOG;IACG,GAAG,IAAI,OAAO,CAAC,uBAAuB,CAAC;IA6C7C;;;;OAIG;YACW,MAAM;IAiDpB;;;;OAIG;YACW,MAAM;IAiDpB;;;;OAIG;YACW,iBAAiB;IAsD/B;;;;;;;OAOG;YACW,0BAA0B;IA6BxC;;;;;;;;;;OAUG;YACW,kBAAkB;CAkChC"}

package/dist/experiments/baselines/frontier-balanced.d.ts

@@ -17,6 +17,8 @@ export interface FrontierBalancedResult {
     visitedPerFrontier: Array<Set<string>>;
     /** Statistics about the expansion */
     stats: FrontierBalancedStats;
+    /** Maps each node to the iteration when it was first discovered */
+    nodeDiscoveryIteration: Map<string, number>;
 }
 /**
  * Statistics collected during frontier-balanced expansion.
@@ -61,6 +63,7 @@ export declare class FrontierBalancedExpansion<T> {
     private readonly paths;
     private readonly sampledEdges;
     private stats;
+    private readonly nodeDiscoveryIteration;
     private lastActiveFrontier;
     /**
      * Create a new frontier-balanced expansion.

package/dist/experiments/baselines/frontier-balanced.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frontier-balanced.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/frontier-balanced.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,0DAA0D;IAC1D,KAAK,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAEpE,kDAAkD;IAClD,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,4CAA4C;IAC5C,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,kDAAkD;IAClD,kBAAkB,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvC,qCAAqC;IACrC,KAAK,EAAE,qBAAqB,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACrC,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAC;IAEtB,4BAA4B;IAC5B,cAAc,EAAE,MAAM,CAAC;IAEvB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IAEnB,0CAA0C;IAC1C,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAExC,mDAAmD;IACnD,gBAAgB,EAAE,MAAM,CAAC;CACzB;AAoBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,yBAAyB,CAAC,CAAC;IAetC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAfvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IACjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoE;IAC1F,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAClD,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,kBAAkB,CAAK;IAE/B;;;;;;OAMG;gBAEe,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE;IAyB1C;;;;;;OAMG;IACG,GAAG,IAAI,OAAO,CAAC,sBAAsB,CAAC;IA8E5C;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAkCvB;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAWlB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAMpB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CASvB"}
+{"version":3,"file":"frontier-balanced.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/frontier-balanced.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,0DAA0D;IAC1D,KAAK,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAEpE,kDAAkD;IAClD,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,4CAA4C;IAC5C,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,kDAAkD;IAClD,kBAAkB,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvC,qCAAqC;IACrC,KAAK,EAAE,qBAAqB,CAAC;IAE7B,mEAAmE;IACnE,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACrC,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAC;IAEtB,4BAA4B;IAC5B,cAAc,EAAE,MAAM,CAAC;IAEvB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IAEnB,0CAA0C;IAC1C,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAExC,mDAAmD;IACnD,gBAAgB,EAAE,MAAM,CAAC;CACzB;AAoBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,yBAAyB,CAAC,CAAC;IAgBtC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAhBvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IACjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoE;IAC1F,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAClD,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAA6B;IACpE,OAAO,CAAC,kBAAkB,CAAK;IAE/B;;;;;;OAMG;gBAEe,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE;IA0B1C;;;;;;OAMG;IACG,GAAG,IAAI,OAAO,CAAC,sBAAsB,CAAC;IA0F5C;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAkCvB;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAWlB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAMpB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CASvB"}

package/dist/experiments/baselines/index.d.ts

@@ -5,8 +5,24 @@
  * - StandardBfsExpansion: No prioritisation (FIFO queue)
  * - FrontierBalancedExpansion: Cerf et al. balancing (smallest frontier first)
  * - RandomPriorityExpansion: Null hypothesis (random selection)
+ * - DelayedTerminationExpansion: BFS with delayed termination after overlap
+ * - DegreeSurpriseExpansion: Local structural anomaly prioritisation
+ * - EnsembleExpansion: Union of BFS, DFS, and degree-priority
+ * - CrossSeedAffinityExpansion: Frontier-aware degree prioritisation
+ * - retroactivePathEnumeration: Post-process any expansion for exhaustive paths
  */
+export { CrossSeedAffinityExpansion, type CrossSeedAffinityResult, type CrossSeedAffinityStats, } from './cross-seed-affinity';
+export { DegreeSurpriseExpansion, type DegreeSurpriseResult, type DegreeSurpriseStats, } from './degree-surprise';
+export { type DelayedTerminationConfig, DelayedTerminationExpansion, type DelayedTerminationResult, type DelayedTerminationStats, } from './delayed-termination';
+export { EnsembleExpansion, type EnsembleExpansionResult, type EnsembleExpansionStats, } from './ensemble-expansion';
 export { FrontierBalancedExpansion, type FrontierBalancedResult, type FrontierBalancedStats, } from './frontier-balanced';
 export { RandomPriorityExpansion, type RandomPriorityResult, type RandomPriorityStats, } from './random-priority';
+export { type ExpansionResult, retroactivePathEnumeration, type RetroactivePathEnumerationResult, type RetroactivePathEnumerationStats, } from './retroactive-path-enum';
 export { type BfsExpansionStats, StandardBfsExpansion, type StandardBfsResult } from './standard-bfs';
+export { type BetweennessConfig, betweennessRanking } from './betweenness-ranking';
+export { type DegreeRankingConfig, degreeSumRanking } from './degree-sum-ranking';
+export { jaccardArithmeticRanking, type JaccardRankingConfig } from './jaccard-arithmetic-ranking';
+export { type PageRankRankingConfig, pageRankSumRanking } from './pagerank-sum-ranking';
+export { type RandomPathConfig, randomPathRanking } from './random-path-ranking';
+export { type ShortestPathConfig, shortestPathRanking } from './shortest-path-ranking';
 //# sourceMappingURL=index.d.ts.map

package/dist/experiments/baselines/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACN,yBAAyB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,GAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACN,uBAAuB,EACvB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,iBAAiB,EAAC,oBAAoB,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACN,0BAA0B,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACN,uBAAuB,EACvB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACN,KAAK,wBAAwB,EAC7B,2BAA2B,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,GAC5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACN,iBAAiB,EACjB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,GAC3B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACN,yBAAyB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,GAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACN,uBAAuB,EACvB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACN,KAAK,eAAe,EACpB,0BAA0B,EAC1B,KAAK,gCAAgC,EACrC,KAAK,+BAA+B,GACpC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,KAAK,iBAAiB,EAAC,oBAAoB,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGrG,OAAO,EAAE,KAAK,iBAAiB,EAAC,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EAAE,KAAK,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EAAE,wBAAwB,EAAC,KAAK,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAClG,OAAO,EAAE,KAAK,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACxF,OAAO,EAAE,KAAK,gBAAgB,EAAC,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,KAAK,kBAAkB,EAAC,mBAAmB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/experiments/baselines/jaccard-arithmetic-ranking.d.ts

@@ -0,0 +1,38 @@
+import { Graph } from '../../algorithms/graph/graph';
+import { RankedPath } from '../../algorithms/pathfinding/path-ranking';
+import { Edge, Node } from '../../algorithms/types/graph';
+import { Option } from '../../algorithms/types/option';
+import { Result } from '../../algorithms/types/result';
+/**
+ * Configuration for Jaccard arithmetic ranking.
+ */
+export interface JaccardRankingConfig {
+    /**
+     * Traversal mode for path finding.
+     */
+    traversalMode?: "directed" | "undirected";
+    /**
+     * Maximum number of paths to return.
+     */
+    maxPaths?: number;
+}
+/**
+ * Rank paths between two nodes by arithmetic mean of Jaccard similarity.
+ *
+ * This baseline ranks paths by the arithmetic mean of Jaccard similarity
+ * coefficients between consecutive node pairs along the path. Paths
+ * where adjacent nodes share more neighbours receive higher scores.
+ *
+ * @template N - Node type
+ * @template E - Edge type
+ * @param graph - The graph to search
+ * @param startId - Source node ID
+ * @param endId - Target node ID
+ * @param config - Optional configuration
+ * @returns Result containing Jaccard-ranked paths or error
+ */
+export declare const jaccardArithmeticRanking: <N extends Node, E extends Edge>(graph: Graph<N, E>, startId: string, endId: string, config?: JaccardRankingConfig) => Result<Option<RankedPath<N, E>[]>, {
+    type: string;
+    message: string;
+}>;
+//# sourceMappingURL=jaccard-arithmetic-ranking.d.ts.map

package/dist/experiments/baselines/jaccard-arithmetic-ranking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jaccard-arithmetic-ranking.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/jaccard-arithmetic-ranking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAE1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAE5E,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,IAAI,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAQ,KAAK,MAAM,EAAQ,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAqB,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC;;OAEG;IACH,aAAa,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC;IAE1C;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AA+KD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,IAAI,EAAE,CAAC,SAAS,IAAI,EACtE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAClB,SAAS,MAAM,EACf,OAAO,MAAM,EACb,SAAQ,oBAAyB,KAC/B,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CA6DtE,CAAC"}

package/dist/experiments/baselines/pagerank-sum-ranking.d.ts

@@ -0,0 +1,46 @@
+import { Graph } from '../../algorithms/graph/graph';
+import { RankedPath } from '../../algorithms/pathfinding/path-ranking';
+import { Edge, Node } from '../../algorithms/types/graph';
+import { Option } from '../../algorithms/types/option';
+import { Result } from '../../algorithms/types/result';
+/**
+ * Configuration for PageRank sum ranking.
+ */
+export interface PageRankRankingConfig {
+    /**
+     * Traversal mode for path finding.
+     */
+    traversalMode?: "directed" | "undirected";
+    /**
+     * Maximum number of paths to return.
+     */
+    maxPaths?: number;
+    /**
+     * Damping factor for PageRank (default: 0.85).
+     */
+    damping?: number;
+    /**
+     * Maximum number of power iterations (default: 100).
+     */
+    iterations?: number;
+}
+/**
+ * Rank paths between two nodes by sum of PageRank scores.
+ *
+ * This baseline ranks paths by the sum of PageRank scores of all nodes
+ * along the path. Paths through globally important nodes (as measured
+ * by PageRank) receive higher scores.
+ *
+ * @template N - Node type
+ * @template E - Edge type
+ * @param graph - The graph to search
+ * @param startId - Source node ID
+ * @param endId - Target node ID
+ * @param config - Optional configuration
+ * @returns Result containing PageRank-ranked paths or error
+ */
+export declare const pageRankSumRanking: <N extends Node, E extends Edge>(graph: Graph<N, E>, startId: string, endId: string, config?: PageRankRankingConfig) => Result<Option<RankedPath<N, E>[]>, {
+    type: string;
+    message: string;
+}>;
+//# sourceMappingURL=pagerank-sum-ranking.d.ts.map

package/dist/experiments/baselines/pagerank-sum-ranking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagerank-sum-ranking.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/pagerank-sum-ranking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAE1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAE5E,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,IAAI,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAQ,KAAK,MAAM,EAAQ,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAqB,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACrC;;OAEG;IACH,aAAa,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC;IAE1C;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AA+PD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,IAAI,EAAE,CAAC,SAAS,IAAI,EAChE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAClB,SAAS,MAAM,EACf,OAAO,MAAM,EACb,SAAQ,qBAA0B,KAChC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAsDtE,CAAC"}

package/dist/experiments/baselines/random-path-ranking.d.ts

@@ -0,0 +1,42 @@
+import { Graph } from '../../algorithms/graph/graph';
+import { RankedPath } from '../../algorithms/pathfinding/path-ranking';
+import { Edge, Node } from '../../algorithms/types/graph';
+import { Option } from '../../algorithms/types/option';
+import { Result } from '../../algorithms/types/result';
+/**
+ * Configuration for random path ranking.
+ */
+export interface RandomPathConfig {
+    /**
+     * Traversal mode for path finding.
+     */
+    traversalMode?: "directed" | "undirected";
+    /**
+     * Maximum number of paths to return.
+     */
+    maxPaths?: number;
+    /**
+     * Random seed for reproducibility.
+     */
+    seed?: number;
+}
+/**
+ * Rank paths between two nodes randomly.
+ *
+ * This baseline serves as a statistical control. All paths receive
+ * the same score (1.0), but their order is randomised. This helps
+ * establish whether Path Salience Ranking provides meaningful improvements.
+ *
+ * @template N - Node type
+ * @template E - Edge type
+ * @param graph - The graph to search
+ * @param startId - Source node ID
+ * @param endId - Target node ID
+ * @param config - Optional configuration including seed for reproducibility
+ * @returns Result containing randomly-ranked paths or error
+ */
+export declare const randomPathRanking: <N extends Node, E extends Edge>(graph: Graph<N, E>, startId: string, endId: string, config?: RandomPathConfig) => Result<Option<RankedPath<N, E>[]>, {
+    type: string;
+    message: string;
+}>;
+//# sourceMappingURL=random-path-ranking.d.ts.map

package/dist/experiments/baselines/random-path-ranking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-path-ranking.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/random-path-ranking.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAE1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAE5E,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,IAAI,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAQ,KAAK,MAAM,EAAQ,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAqB,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC;;OAEG;IACH,aAAa,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC;IAE1C;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAoKD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,IAAI,EAAE,CAAC,SAAS,IAAI,EAC/D,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAClB,SAAS,MAAM,EACf,OAAO,MAAM,EACb,SAAQ,gBAAqB,KAC3B,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAsCtE,CAAC"}

package/dist/experiments/baselines/random-priority.d.ts

@@ -17,6 +17,8 @@ export interface RandomPriorityResult {
     visitedPerFrontier: Array<Set<string>>;
     /** Statistics about the expansion */
     stats: RandomPriorityStats;
+    /** Maps each node to the iteration when it was first discovered */
+    nodeDiscoveryIteration: Map<string, number>;
 }
 /**
  * Statistics collected during random-priority expansion.
@@ -60,6 +62,7 @@ export declare class RandomPriorityExpansion<T> {
     private readonly sampledEdges;
     private readonly rng;
     private stats;
+    private readonly nodeDiscoveryIteration;
     /**
      * Create a new random-priority expansion.
      *

package/dist/experiments/baselines/random-priority.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random-priority.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/random-priority.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,0DAA0D;IAC1D,KAAK,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAEpE,kDAAkD;IAClD,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,4CAA4C;IAC5C,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,kDAAkD;IAClD,kBAAkB,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvC,qCAAqC;IACrC,KAAK,EAAE,mBAAmB,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAC;IAEtB,4BAA4B;IAC5B,cAAc,EAAE,MAAM,CAAC;IAEvB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IAEnB,0CAA0C;IAC1C,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AA+CD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,uBAAuB,CAAC,CAAC;IAgBpC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAhBvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IACjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoE;IAC1F,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAClD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,KAAK,CAAsB;IAEnC;;;;;;;OAOG;gBAEe,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,EACzC,IAAI,SAAK;IA0BV;;;;;;OAMG;IACG,GAAG,IAAI,OAAO,CAAC,oBAAoB,CAAC;IA2E1C;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAW5B;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAkCvB;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAWlB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAMpB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CASvB"}
+{"version":3,"file":"random-priority.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/random-priority.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,0DAA0D;IAC1D,KAAK,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAEpE,kDAAkD;IAClD,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,4CAA4C;IAC5C,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,kDAAkD;IAClD,kBAAkB,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvC,qCAAqC;IACrC,KAAK,EAAE,mBAAmB,CAAC;IAE3B,mEAAmE;IACnE,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAC;IAEtB,4BAA4B;IAC5B,cAAc,EAAE,MAAM,CAAC;IAEvB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IAEnB,0CAA0C;IAC1C,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AA+CD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,uBAAuB,CAAC,CAAC;IAiBpC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAjBvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IACjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoE;IAC1F,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAClD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAA6B;IAEpE;;;;;;;OAOG;gBAEe,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,EACzC,IAAI,SAAK;IA2BV;;;;;;OAMG;IACG,GAAG,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAuF1C;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAW5B;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAkCvB;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAWlB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAMpB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CASvB"}

package/dist/experiments/baselines/retroactive-path-enum.d.ts

@@ -0,0 +1,91 @@
+import { GraphExpander } from '../../interfaces/graph-expander';
+/**
+ * Generic expansion result type - compatible with all baseline results.
+ */
+export interface ExpansionResult {
+    /** Union of all nodes visited during expansion */
+    sampledNodes: Set<string>;
+    /** Set of edges visited during expansion */
+    sampledEdges: Set<string>;
+}
+/**
+ * Result from retroactive path enumeration.
+ */
+export interface RetroactivePathEnumerationResult {
+    /** All simple paths found between seed pairs */
+    paths: Array<{
+        fromSeed: number;
+        toSeed: number;
+        nodes: string[];
+    }>;
+    /** Statistics about enumeration */
+    stats: RetroactivePathEnumerationStats;
+}
+/**
+ * Statistics collected during retroactive path enumeration.
+ */
+export interface RetroactivePathEnumerationStats {
+    /** Total simple paths enumerated */
+    totalPaths: number;
+    /** Number of seed pairs processed */
+    seedPairsProcessed: number;
+    /** Average paths per seed pair */
+    avgPathsPerPair: number;
+    /** Path length distribution */
+    pathLengthDistribution: Map<number, number>;
+}
+/**
+ * Retroactive Path Enumeration
+ *
+ * Post-processing function that takes ANY expansion result (from BFS,
+ * degree-prioritised, random, etc.) and enumerates ALL simple paths
+ * through the discovered subgraph.
+ *
+ * **Key Properties**:
+ * - Works with any expansion result (union of sampled nodes)
+ * - Uses DFS with backtracking to find all simple paths
+ * - Depth-limited for tractability on large subgraphs
+ * - Pure post-processing (doesn't modify original expansion)
+ *
+ * **Experimental Purpose**:
+ * Disentangles path discovery mechanism from path enumeration completeness.
+ * Tests whether different expansion strategies produce subgraphs with
+ * different path densities or diversity, independent of online path detection.
+ *
+ * **Use Case**:
+ * Compare path diversity across expansion strategies after exhaustive
+ * enumeration. If Strategy A finds more paths than Strategy B retroactively,
+ * A's subgraph is structurally richer (not just faster to converge).
+ *
+ * **Note**: This can be expensive on dense subgraphs. Use maxLength to
+ * control tractability.
+ */
+/**
+ * Enumerate all simple paths between seed pairs in a sampled subgraph.
+ *
+ * @param result - Expansion result containing sampledNodes
+ * @param expander - Graph expander providing neighbour access
+ * @param seeds - Array of seed node IDs (N >= 2)
+ * @param maxLength - Maximum path length to explore (default: 20)
+ * @returns Enumeration results including all discovered paths
+ *
+ * @example
+ * ```typescript
+ * // Run standard BFS
+ * const bfsExpansion = new StandardBfsExpansion(expander, seeds);
+ * const bfsResult = await bfsExpansion.run();
+ *
+ * // Retroactively enumerate all paths through BFS subgraph
+ * const enumResult = await retroactivePathEnumeration(
+ *   bfsResult,
+ *   expander,
+ *   seeds,
+ *   20
+ * );
+ *
+ * console.log(`BFS found ${bfsResult.paths.length} paths online`);
+ * console.log(`Retroactive enumeration found ${enumResult.paths.length} paths`);
+ * ```
+ */
+export declare const retroactivePathEnumeration: <T>(result: ExpansionResult, expander: GraphExpander<T>, seeds: readonly string[], maxLength?: number) => Promise<RetroactivePathEnumerationResult>;
+//# sourceMappingURL=retroactive-path-enum.d.ts.map

package/dist/experiments/baselines/retroactive-path-enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retroactive-path-enum.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/retroactive-path-enum.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,eAAe;IAC/B,kDAAkD;IAClD,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,4CAA4C;IAC5C,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,gCAAgC;IAChD,gDAAgD;IAChD,KAAK,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAEpE,mCAAmC;IACnC,KAAK,EAAE,+BAA+B,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC/C,oCAAoC;IACpC,UAAU,EAAE,MAAM,CAAC;IAEnB,qCAAqC;IACrC,kBAAkB,EAAE,MAAM,CAAC;IAE3B,kCAAkC;IAClC,eAAe,EAAE,MAAM,CAAC;IAExB,+BAA+B;IAC/B,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,0BAA0B,GAAU,CAAC,EAAE,QAAQ,eAAe,EAAE,UAAU,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,SAAS,MAAM,EAAE,EAAE,kBAAc,KAAG,OAAO,CAAC,gCAAgC,CAoD3L,CAAC"}

package/dist/experiments/baselines/shortest-path-ranking.d.ts

@@ -0,0 +1,40 @@
+import { Graph } from '../../algorithms/graph/graph';
+import { RankedPath } from '../../algorithms/pathfinding/path-ranking';
+import { Edge, Node } from '../../algorithms/types/graph';
+import { Option } from '../../algorithms/types/option';
+import { Result } from '../../algorithms/types/result';
+/**
+ * Configuration for shortest path ranking.
+ */
+export interface ShortestPathConfig {
+    /**
+     * Traversal mode for path finding.
+     */
+    traversalMode?: "directed" | "undirected";
+    /**
+     * Maximum number of paths to return.
+     */
+    maxPaths?: number;
+}
+/**
+ * Rank paths between two nodes by shortest path length.
+ *
+ * This baseline ranks paths purely by their length, with shorter paths
+ * receiving higher scores. The score is computed as 1/(length + 1).
+ *
+ * Time Complexity: O(V + E) for BFS
+ * Space Complexity: O(V + E) for predecessor tracking
+ *
+ * @template N - Node type
+ * @template E - Edge type
+ * @param graph - The graph to search
+ * @param startId - Source node ID
+ * @param endId - Target node ID
+ * @param config - Optional configuration
+ * @returns Result containing ranked paths or error
+ */
+export declare const shortestPathRanking: <N extends Node, E extends Edge>(graph: Graph<N, E>, startId: string, endId: string, config?: ShortestPathConfig) => Result<Option<RankedPath<N, E>[]>, {
+    type: string;
+    message: string;
+}>;
+//# sourceMappingURL=shortest-path-ranking.d.ts.map

package/dist/experiments/baselines/shortest-path-ranking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortest-path-ranking.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/shortest-path-ranking.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAE1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAE5E,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,IAAI,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAQ,KAAK,MAAM,EAAQ,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAqB,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;OAEG;IACH,aAAa,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC;IAE1C;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAyID;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,IAAI,EAAE,CAAC,SAAS,IAAI,EACjE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAClB,SAAS,MAAM,EACf,OAAO,MAAM,EACb,SAAQ,kBAAuB,KAC7B,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CA2CtE,CAAC"}

package/dist/experiments/baselines/standard-bfs.d.ts

@@ -17,6 +17,11 @@ export interface StandardBfsResult {
     visitedPerFrontier: Array<Set<string>>;
     /** Statistics about the expansion */
     stats: BfsExpansionStats;
+    /**
+     * Maps each sampled node to the iteration when it was first discovered.
+     * Used for computing coverage efficiency metrics.
+     */
+    nodeDiscoveryIteration: Map<string, number>;
 }
 /**
  * Statistics collected during BFS expansion.
@@ -56,6 +61,8 @@ export declare class StandardBfsExpansion<T> {
     private readonly paths;
     private readonly sampledEdges;
     private stats;
+    /** Tracks when each node was first discovered (iteration number) */
+    private readonly nodeDiscoveryIteration;
     /**
      * Create a new standard BFS expansion.
      *

package/dist/experiments/baselines/standard-bfs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"standard-bfs.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/standard-bfs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,0DAA0D;IAC1D,KAAK,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAEpE,kDAAkD;IAClD,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,4CAA4C;IAC5C,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,kDAAkD;IAClD,kBAAkB,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvC,qCAAqC;IACrC,KAAK,EAAE,iBAAiB,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAC;IAEtB,4BAA4B;IAC5B,cAAc,EAAE,MAAM,CAAC;IAEvB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IAEnB,0CAA0C;IAC1C,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAoBD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,oBAAoB,CAAC,CAAC;IAcjC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAdvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IACjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoE;IAC1F,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAClD,OAAO,CAAC,KAAK,CAAoB;IAEjC;;;;;;OAMG;gBAEe,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE;IAwB1C;;;;;;OAMG;IACG,GAAG,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAwEvC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAkCvB;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAWlB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAMpB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CASvB"}
+{"version":3,"file":"standard-bfs.d.ts","sourceRoot":"","sources":["../../../src/experiments/baselines/standard-bfs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,0DAA0D;IAC1D,KAAK,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAEpE,kDAAkD;IAClD,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,4CAA4C;IAC5C,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,kDAAkD;IAClD,kBAAkB,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvC,qCAAqC;IACrC,KAAK,EAAE,iBAAiB,CAAC;IAEzB;;;OAGG;IACH,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAC;IAEtB,4BAA4B;IAC5B,cAAc,EAAE,MAAM,CAAC;IAEvB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IAEnB,0CAA0C;IAC1C,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAoBD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,oBAAoB,CAAC,CAAC;IAgBjC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAhBvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IACjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoE;IAC1F,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAClD,OAAO,CAAC,KAAK,CAAoB;IACjC,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAA6B;IAEpE;;;;;;OAMG;gBAEe,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,MAAM,EAAE;IA2B1C;;;;;;OAMG;IACG,GAAG,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAqFvC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAkCvB;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAWlB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAMpB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CASvB"}

package/dist/experiments/evaluation/__tests__/harness/evaluation.exp.integration.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Algorithm evaluation harness test.
+ *
+ * Runs all algorithms on all fixtures and outputs detailed metrics for comparison.
+ * This test focuses on BEHAVIOUR rather than raw performance:
+ *
+ * - Correctness: Do algorithms find valid paths?
+ * - Exploration efficiency: How many nodes/edges are expanded?
+ * - Search behaviour: How does traversal order differ?
+ * - Diversity: How varied are the discovered paths?
+ */
+export {};
+//# sourceMappingURL=evaluation.exp.integration.test.d.ts.map

package/dist/experiments/evaluation/__tests__/harness/evaluation.exp.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation.exp.integration.test.d.ts","sourceRoot":"","sources":["../../../../../src/experiments/evaluation/__tests__/harness/evaluation.exp.integration.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/experiments/evaluation/__tests__/harness/evaluator.d.ts

@@ -0,0 +1,55 @@
+import { AlgorithmRunResult, GraphFixture } from './types';
+/**
+ * Algorithm configuration.
+ */
+interface AlgorithmConfig {
+    /** Display name */
+    name: string;
+    /** Factory to create the algorithm */
+    create: (expander: import('../../../../interfaces/graph-expander').GraphExpander<unknown>, seeds: readonly string[]) => {
+        run: () => Promise<{
+            paths: Array<{
+                fromSeed: number;
+                toSeed: number;
+                nodes: string[];
+            }>;
+            sampledNodes: Set<string>;
+            sampledEdges: Set<string>;
+            stats: {
+                nodesExpanded: number;
+                edgesTraversed: number;
+                iterations: number;
+                degreeDistribution: Map<string, number>;
+            };
+        }>;
+    };
+}
+/**
+ * All algorithms to evaluate.
+ */
+export declare const algorithms: AlgorithmConfig[];
+/**
+ * Run a single algorithm on a single graph with given seeds.
+ * @param algorithm
+ * @param fixture
+ * @param seeds
+ */
+export declare const runAlgorithmOnGraph: (algorithm: AlgorithmConfig, fixture: GraphFixture, seeds: string[]) => Promise<AlgorithmRunResult>;
+/**
+ * Run full evaluation: all algorithms × all fixtures × all seed configurations.
+ */
+export declare const runFullEvaluation: () => Promise<{
+    results: AlgorithmRunResult[];
+    summary: {
+        totalRuns: number;
+        fixtures: number;
+        algorithms: number;
+    };
+}>;
+/**
+ * Format results for JSON output.
+ * @param results
+ */
+export declare const formatResultsForJson: (results: AlgorithmRunResult[]) => string;
+export {};
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/experiments/evaluation/__tests__/harness/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../../../../src/experiments/evaluation/__tests__/harness/evaluator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,OAAO,KAAK,EAAE,kBAAkB,EAAoB,YAAY,EAAc,MAAM,SAAS,CAAC;AAE9F;;GAEG;AACH,UAAU,eAAe;IACxB,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IAEb,sCAAsC;IACtC,MAAM,EAAE,CACP,QAAQ,EAAE,OAAO,kCAAkC,EAAE,aAAa,CAAC,OAAO,CAAC,EAC3E,KAAK,EAAE,SAAS,MAAM,EAAE,KACpB;QACJ,GAAG,EAAE,MAAM,OAAO,CAAC;YAClB,KAAK,EAAE,KAAK,CAAC;gBAAE,QAAQ,EAAE,MAAM,CAAC;gBAAC,MAAM,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE,MAAM,EAAE,CAAA;aAAE,CAAC,CAAC;YACpE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;YAC1B,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;YAC1B,KAAK,EAAE;gBACN,aAAa,EAAE,MAAM,CAAC;gBACtB,cAAc,EAAE,MAAM,CAAC;gBACvB,UAAU,EAAE,MAAM,CAAC;gBACnB,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;aACxC,CAAC;SACF,CAAC,CAAC;KACH,CAAC;CACF;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,eAAe,EAiBvC,CAAC;AAyJF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAU,WAAW,eAAe,EAAE,SAAS,YAAY,EAAE,OAAO,MAAM,EAAE,KAAG,OAAO,CAAC,kBAAkB,CAkDxI,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAa,OAAO,CAAC;IAClD,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,OAAO,EAAE;QACR,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;KACnB,CAAC;CACF,CA+BA,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,kBAAkB,EAAE,KAAG,MA2BpE,CAAC"}