@graphty/algorithms 2.0.2 → 2.0.4

package/README.md

@@ -54,9 +54,8 @@ _Note: Optimizations activate automatically for graphs ≥10K nodes to avoid con
 
 ### Learn More
 
-- 📖 [Performance Guide](docs/PERFORMANCE_GUIDE.md) - Detailed optimization explanations
-- 🔄 [Migration Guide](docs/MIGRATION_GUIDE.md) - Upgrading from older versions
-- 💾 [Memory vs Speed Tradeoffs](docs/PERFORMANCE_GUIDE.md#memory-vs-speed-tradeoffs) - Making the right choices
+- 📖 [Performance Guide](docs/guide/performance.md) - Detailed optimization explanations
+- 💾 [Memory Optimization](docs/guide/performance.md#memory-optimization) - Making the right choices
 
 ## Installation
 
@@ -111,8 +110,8 @@ class Graph {
 ```typescript
 interface GraphConfig {
     directed: boolean; // Default: false
-    allowSelfLoops: boolean; // Default: false
-    allowParallelEdges: boolean; // Default: false
+    allowSelfLoops: boolean; // Default: true
+    allowParallelEdges: boolean; // Default: false. When true, re-adding a pair replaces its edge (one edge per pair)
 }
 ```
 
@@ -1050,68 +1049,68 @@ The library includes comprehensive examples demonstrating each algorithm. You ca
 
 - **[Browse Interactive HTML Examples](https://graphty.app/algorithms/examples/)** - Visual demonstrations with step-by-step execution
 - **[View Performance Benchmarks](https://graphty.app/algorithms/benchmarks/)** - Comparative analysis of algorithm performance
-- **[Explore Code Examples](https://github.com/graphty-org/algorithms/tree/main/examples)** - Implementation examples for each algorithm
+- **[Explore Code Examples](https://github.com/graphty-org/graphty-monorepo/tree/master/algorithms/examples)** - Implementation examples for each algorithm
 
 ### Basic Algorithms
 
-- [BFS Traversal](https://github.com/graphty-org/algorithms/blob/main/examples/bfs-example.js) - Breadth-first search and shortest paths
-- [DFS Traversal](https://github.com/graphty-org/algorithms/blob/main/examples/dfs-example.js) - Depth-first search and applications
-- [Dijkstra's Algorithm](https://github.com/graphty-org/algorithms/blob/main/examples/dijkstra-example.js) - Weighted shortest paths
-- [Bellman-Ford](https://github.com/graphty-org/algorithms/blob/main/examples/bellman-ford-example.js) - Shortest paths with negative weights
-- [Floyd-Warshall](https://github.com/graphty-org/algorithms/blob/main/examples/floyd-warshall-example.js) - All pairs shortest paths
+- [BFS Traversal](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/bfs-example.js) - Breadth-first search and shortest paths
+- [DFS Traversal](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/dfs-example.js) - Depth-first search and applications
+- [Dijkstra's Algorithm](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/dijkstra-example.js) - Weighted shortest paths
+- [Bellman-Ford](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/bellman-ford-example.js) - Shortest paths with negative weights
+- [Floyd-Warshall](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/floyd-warshall-example.js) - All pairs shortest paths
 
 ### Centrality Measures
 
-- [Degree Centrality](https://github.com/graphty-org/algorithms/blob/main/examples/degree-centrality-example.js) - Node importance by connections
-- [Betweenness Centrality](https://github.com/graphty-org/algorithms/blob/main/examples/betweenness-centrality-example.js) - Bridge nodes
-- [Closeness Centrality](https://github.com/graphty-org/algorithms/blob/main/examples/closeness-centrality-example.js) - Central nodes
-- [PageRank](https://github.com/graphty-org/algorithms/blob/main/examples/pagerank-example.js) - Node ranking algorithm
-- [Eigenvector Centrality](https://github.com/graphty-org/algorithms/blob/main/examples/eigenvector-centrality-example.js) - Influence from important nodes
-- [Katz Centrality](https://github.com/graphty-org/algorithms/blob/main/examples/katz-centrality-example.js) - Weighted path counting
-- [HITS Algorithm](https://github.com/graphty-org/algorithms/blob/main/examples/hits-algorithm-example.js) - Hub and authority scores
+- [Degree Centrality](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/degree-centrality-example.js) - Node importance by connections
+- [Betweenness Centrality](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/betweenness-centrality-example.js) - Bridge nodes
+- [Closeness Centrality](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/closeness-centrality-example.js) - Central nodes
+- [PageRank](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/pagerank-example.js) - Node ranking algorithm
+- [Eigenvector Centrality](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/eigenvector-centrality-example.js) - Influence from important nodes
+- [Katz Centrality](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/katz-centrality-example.js) - Weighted path counting
+- [HITS Algorithm](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/hits-algorithm-example.js) - Hub and authority scores
 
 ### Graph Structure
 
-- [Connected Components](https://github.com/graphty-org/algorithms/blob/main/examples/connected-components-example.js) - Find graph components
-- [Kruskal's MST](https://github.com/graphty-org/algorithms/blob/main/examples/kruskal-example.js) - Minimum spanning tree
-- [Prim's MST](https://github.com/graphty-org/algorithms/blob/main/examples/prim-example.js) - Alternative MST algorithm
+- [Connected Components](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/connected-components-example.js) - Find graph components
+- [Kruskal's MST](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/kruskal-example.js) - Minimum spanning tree
+- [Prim's MST](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/prim-example.js) - Alternative MST algorithm
 
 ### Community Detection
 
-- [Louvain Method](https://github.com/graphty-org/algorithms/blob/main/examples/louvain-example.js) - Modularity-based communities
-- [Leiden Algorithm](https://github.com/graphty-org/algorithms/blob/main/examples/leiden-community.ts) - Improved Louvain
-- [Label Propagation](https://github.com/graphty-org/algorithms/blob/main/examples/label-propagation.ts) - Fast community detection
-- [Girvan-Newman](https://github.com/graphty-org/algorithms/blob/main/examples/girvan-newman-example.js) - Hierarchical communities
+- [Louvain Method](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/louvain-example.js) - Modularity-based communities
+- [Leiden Algorithm](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/leiden-community.ts) - Improved Louvain
+- [Label Propagation](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/label-propagation.ts) - Fast community detection
+- [Girvan-Newman](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/girvan-newman-example.js) - Hierarchical communities
 
 ### Clustering
 
-- [Hierarchical Clustering](https://github.com/graphty-org/algorithms/blob/main/examples/hierarchical-clustering.ts) - Graph clustering
-- [K-Core Decomposition](https://github.com/graphty-org/algorithms/blob/main/examples/k-core-decomposition.ts) - Core analysis
-- [Spectral Clustering](https://github.com/graphty-org/algorithms/blob/main/examples/spectral-clustering-example.js) - Eigenvalue-based clustering
-- [MCL Clustering](https://github.com/graphty-org/algorithms/blob/main/examples/mcl-clustering-example.js) - Markov clustering
+- [Hierarchical Clustering](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/hierarchical-clustering.ts) - Graph clustering
+- [K-Core Decomposition](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/k-core-decomposition.ts) - Core analysis
+- [Spectral Clustering](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/spectral-clustering-example.js) - Eigenvalue-based clustering
+- [MCL Clustering](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/mcl-clustering-example.js) - Markov clustering
 
 ### Matching
 
-- [Bipartite Matching](https://github.com/graphty-org/algorithms/blob/main/examples/bipartite-matching-example.js) - Job assignment, dating apps
-- [Graph Isomorphism](https://github.com/graphty-org/algorithms/blob/main/examples/graph-isomorphism-example.js) - Structural equivalence
+- [Bipartite Matching](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/bipartite-matching-example.js) - Job assignment, dating apps
+- [Graph Isomorphism](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/graph-isomorphism-example.js) - Structural equivalence
 
 ### Link Prediction
 
-- [Common Neighbors](https://github.com/graphty-org/algorithms/blob/main/examples/common-neighbors-example.js) - Friend suggestions
-- [Adamic-Adar](https://github.com/graphty-org/algorithms/blob/main/examples/adamic-adar-example.js) - Weighted predictions
+- [Common Neighbors](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/common-neighbors-example.js) - Friend suggestions
+- [Adamic-Adar](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/adamic-adar-example.js) - Weighted predictions
 
 ### Advanced Algorithms
 
-- [A\* Pathfinding](https://github.com/graphty-org/algorithms/blob/main/examples/astar-pathfinding.ts) - Heuristic pathfinding
-- [Flow Algorithms](https://github.com/graphty-org/algorithms/blob/main/examples/flow-algorithms.ts) - Maximum flow and applications
-- [Ford-Fulkerson Flow](https://github.com/graphty-org/algorithms/blob/main/examples/ford-fulkerson-flow.ts) - Maximum flow implementation
-- [Minimum Cut](https://github.com/graphty-org/algorithms/blob/main/examples/min-cut.ts) - Graph partitioning
+- [A\* Pathfinding](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/astar-pathfinding.ts) - Heuristic pathfinding
+- [Flow Algorithms](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/flow-algorithms.ts) - Maximum flow and applications
+- [Ford-Fulkerson Flow](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/ford-fulkerson-flow.ts) - Maximum flow implementation
+- [Minimum Cut](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/min-cut.ts) - Graph partitioning
 
 ### Research Algorithms
 
-- [SynC Clustering](https://github.com/graphty-org/algorithms/blob/main/examples/sync-example.js) - Deep learning based clustering
-- [TeraHAC](https://github.com/graphty-org/algorithms/blob/main/examples/terahac-example.js) - Scalable hierarchical clustering
-- [GRSBM](https://github.com/graphty-org/algorithms/blob/main/examples/grsbm-example.js) - Explainable community detection
+- [SynC Clustering](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/sync-example.js) - Deep learning based clustering
+- [TeraHAC](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/terahac-example.js) - Scalable hierarchical clustering
+- [GRSBM](https://github.com/graphty-org/graphty-monorepo/blob/master/algorithms/examples/grsbm-example.js) - Explainable community detection
 
 ## Advanced Usage Examples
 
@@ -1482,7 +1481,7 @@ test/
 
 ## Contributing
 
-We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+We welcome contributions! Please open an issue or a pull request on [GitHub](https://github.com/graphty-org/graphty-monorepo).
 
 ### Commit Convention
 
@@ -1501,5 +1500,5 @@ MIT © Adam Powers
 
 ## Related Projects
 
-- [@graphty/layout](https://github.com/graphty-org/layout) - Graph layout algorithms
-- [@graphty/graphty-element](https://github.com/graphty-org/graphty-element) - 3D graph visualization web component
+- [@graphty/layout](https://github.com/graphty-org/graphty-monorepo/tree/master/layout) - Graph layout algorithms
+- [@graphty/graphty-element](https://github.com/graphty-org/graphty-monorepo/tree/master/graphty-element) - 3D graph visualization web component

package/dist/algorithms.js

@@ -85,7 +85,8 @@ class Graph {
     if (!this.config.allowSelfLoops && source === target) {
       throw new Error("Self-loops are not allowed in this graph");
     }
-    if (!this.config.allowParallelEdges && this.hasEdge(source, target)) {
+    const replacing = this.hasEdge(source, target);
+    if (!this.config.allowParallelEdges && replacing) {
       throw new Error("Parallel edges are not allowed in this graph");
     }
     const edge = { source, target, weight, data };
@@ -107,7 +108,9 @@ class Graph {
         }
       }
     }
-    this.edgeCount++;
+    if (!replacing) {
+      this.edgeCount++;
+    }
     this.mutations++;
   }
   /**
@@ -352,6 +355,23 @@ class ConvergenceError extends Error {
     this.name = "ConvergenceError";
   }
 }
+class PathWalkError extends Error {
+  /**
+   * Builds the error and its message.
+   * @param source - The search's source node index
+   * @param target - The node index the walk started from
+   * @param reason - `"gap"` or `"cycle"`, as above
+   */
+  constructor(source, target, reason) {
+    super(
+      `cannot walk the shortest path from node ${String(source)} to node ${String(target)}: the predecessor array has a ${reason}`
+    );
+    this.source = source;
+    this.target = target;
+    this.reason = reason;
+    this.name = "PathWalkError";
+  }
+}
 var lib = {};
 var SparseTypedFastBitSet = {};
 var utils = {};
@@ -5253,7 +5273,7 @@ class PriorityDeltaPageRank {
   }
 }
 function eigenvectorCentrality(graph, options = {}) {
-  const { maxIterations = 100, tolerance = 1e-6, normalized = true, startVector } = options;
+  const { maxIterations = 100, tolerance = 1e-6, normalized = true, startVector, mode = "in" } = options;
   const nodeIds = Array.from(graph.nodes(), (node) => node.id);
   const keys = nodeIds.map((id) => id.toString());
   const n = keys.length;
@@ -5262,7 +5282,13 @@ function eigenvectorCentrality(graph, options = {}) {
     return centrality;
   }
   const index2 = new Map(keys.map((key, i) => [key, i]));
-  const adjacency = nodeIds.map((id) => Array.from(graph.neighbors(id), (m) => index2.get(m.toString()) ?? 0));
+  const feeders = (id) => {
+    if (!graph.isDirected || mode === "out") {
+      return graph.neighbors(id);
+    }
+    return mode === "in" ? graph.inNeighbors(id) : /* @__PURE__ */ new Set([...graph.inNeighbors(id), ...graph.neighbors(id)]);
+  };
+  const adjacency = nodeIds.map((id) => Array.from(feeders(id), (m) => index2.get(m.toString()) ?? 0));
   if (isNilpotent(adjacency)) {
     for (const key of keys) {
       centrality[key] = 0;
@@ -5550,6 +5576,8 @@ class SimpleDeltaPageRank {
    */
   constructor(graph) {
     this.previousScores = null;
+    this.iterations = 0;
+    this.converged = false;
     if (!graph.isDirected) {
       throw new Error("PageRank requires a directed graph");
     }
@@ -5562,20 +5590,32 @@ class SimpleDeltaPageRank {
    * @param options.dampingFactor - Probability of following a link (default: 0.85)
    * @param options.tolerance - Convergence tolerance threshold (default: 1e-6)
    * @param options.maxIterations - Maximum number of iterations (default: 100)
+   * @param options.initialRanks - Starting scores (missing nodes start at 1/n; normalized to sum 1)
    * @param options.personalization - Personalization vector for Personalized PageRank
    * @param options.weight - Edge attribute name for weighted PageRank
-   * @returns Map of node IDs to their PageRank scores
+   * @returns Map of node IDs to their PageRank scores; `iterations` and `converged` describe the run
    */
   compute(options = {}) {
-    const { dampingFactor = 0.85, tolerance = 1e-6, maxIterations = 100, personalization, weight } = options;
+    const {
+      dampingFactor = 0.85,
+      tolerance = 1e-6,
+      maxIterations = 100,
+      initialRanks,
+      personalization,
+      weight
+    } = options;
+    this.iterations = 0;
+    this.converged = false;
     if (this.nodeCount === 0) {
+      this.converged = true;
       return /* @__PURE__ */ new Map();
     }
     const scores = /* @__PURE__ */ new Map();
     const newScores = /* @__PURE__ */ new Map();
     for (const node of this.graph.nodes()) {
-      scores.set(node.id, 1 / this.nodeCount);
+      scores.set(node.id, initialRanks?.get(node.id) ?? 1 / this.nodeCount);
     }
+    this.normalizeMap(scores);
     const outWeights = /* @__PURE__ */ new Map();
     const danglingNodes = /* @__PURE__ */ new Set();
     for (const node of this.graph.nodes()) {
@@ -5583,8 +5623,7 @@ class SimpleDeltaPageRank {
       let outDegree = 0;
       for (const neighbor of Array.from(this.graph.neighbors(node.id))) {
         outDegree++;
-        const edge = this.graph.getEdge(node.id, neighbor);
-        totalWeight += edge?.weight ?? 1;
+        totalWeight += weight ? this.graph.getEdge(node.id, neighbor)?.weight ?? 1 : 1;
       }
       outWeights.set(node.id, totalWeight);
       if (outDegree === 0) {
@@ -5596,7 +5635,6 @@ class SimpleDeltaPageRank {
       personalVector = new Map(personalization);
       this.normalizeMap(personalVector);
     }
-    let activeNodes = new Set(scores.keys());
     let iteration = 0;
     for (iteration = 0; iteration < maxIterations; iteration++) {
       for (const nodeId of scores.keys()) {
@@ -5622,7 +5660,7 @@ class SimpleDeltaPageRank {
           }
         }
       }
-      for (const nodeId of activeNodes) {
+      for (const nodeId of scores.keys()) {
         const currentRank = scores.get(nodeId) ?? 0;
         const nodeOutWeight = outWeights.get(nodeId) ?? 0;
         if (nodeOutWeight > 0) {
@@ -5638,33 +5676,21 @@ class SimpleDeltaPageRank {
           }
         }
       }
-      const nextActive = /* @__PURE__ */ new Set();
       let maxDiff = 0;
       for (const nodeId of scores.keys()) {
-        const oldRank = scores.get(nodeId) ?? 0;
-        const newRank = newScores.get(nodeId) ?? 0;
-        const diff = Math.abs(newRank - oldRank);
-        maxDiff = Math.max(maxDiff, diff);
-        if (diff > tolerance / 10) {
-          nextActive.add(nodeId);
-          for (const neighbor of Array.from(this.graph.neighbors(nodeId))) {
-            nextActive.add(neighbor);
-          }
-          for (const neighbor of Array.from(this.graph.inNeighbors(nodeId))) {
-            nextActive.add(neighbor);
-          }
-        }
+        maxDiff = Math.max(maxDiff, Math.abs((newScores.get(nodeId) ?? 0) - (scores.get(nodeId) ?? 0)));
       }
       scores.clear();
       for (const [k, v] of newScores) {
         scores.set(k, v);
       }
       newScores.clear();
-      activeNodes = nextActive;
       if (maxDiff < tolerance) {
+        this.converged = true;
         break;
       }
     }
+    this.iterations = this.converged ? iteration + 1 : iteration;
     this.previousScores = new Map(scores);
     return scores;
   }
@@ -5685,6 +5711,8 @@ class SimpleDeltaPageRank {
       return this.compute(options);
     }
     const { dampingFactor = 0.85, tolerance = 1e-6, maxIterations = 100, personalization, weight } = options;
+    this.iterations = 0;
+    this.converged = false;
     const scores = new Map(this.previousScores);
     const newScores = /* @__PURE__ */ new Map();
     for (const node of this.graph.nodes()) {
@@ -5709,8 +5737,7 @@ class SimpleDeltaPageRank {
       let outDegree = 0;
       for (const neighbor of Array.from(this.graph.neighbors(node.id))) {
         outDegree++;
-        const edge = this.graph.getEdge(node.id, neighbor);
-        totalWeight += edge?.weight ?? 1;
+        totalWeight += weight ? this.graph.getEdge(node.id, neighbor)?.weight ?? 1 : 1;
       }
       outWeights.set(node.id, totalWeight);
       if (outDegree === 0) {
@@ -5787,9 +5814,11 @@ class SimpleDeltaPageRank {
       newScores.clear();
       activeNodes = nextActive;
       if (maxDiff < tolerance) {
+        this.converged = true;
         break;
       }
     }
+    this.iterations = this.converged ? iteration + 1 : iteration;
     this.previousScores = new Map(scores);
     return scores;
   }
@@ -5832,6 +5861,9 @@ function pageRank$1(graph, options = {}) {
       tolerance,
       maxIterations
     };
+    if (initialRanks) {
+      deltaOptions.initialRanks = initialRanks;
+    }
     if (personalization) {
       deltaOptions.personalization = personalization;
     }
@@ -5846,9 +5878,8 @@ function pageRank$1(graph, options = {}) {
     }
     return {
       ranks: result2,
-      iterations: maxIterations,
-      // For now, assume we used all iterations
-      converged: true
+      iterations: deltaPageRank.iterations,
+      converged: deltaPageRank.converged
     };
   }
   let ranks = /* @__PURE__ */ new Map();
@@ -5950,7 +5981,8 @@ function pageRank$1(graph, options = {}) {
   }
   return {
     ranks: result,
-    iterations: iteration + 1,
+    // The loop breaks before incrementing on convergence, and leaves at maxIterations otherwise.
+    iterations: converged ? iteration + 1 : iteration,
     converged
   };
 }
@@ -10122,7 +10154,7 @@ function adamicAdarPrediction(graph, options = {}) {
     for (let j = i + 1; j < nodes.length; j++) {
       const source = nodes[i];
       const target = nodes[j];
-      if (!source || !target) {
+      if (source === void 0 || target === void 0) {
         continue;
       }
       if (!includeExisting && graph.hasEdge(source, target)) {
@@ -10300,7 +10332,7 @@ function commonNeighborsPrediction(graph, options = {}) {
     for (let j = i + 1; j < nodes.length; j++) {
       const source = nodes[i];
       const target = nodes[j];
-      if (!source || !target) {
+      if (source === void 0 || target === void 0) {
         continue;
       }
       if (!includeExisting && graph.hasEdge(source, target)) {
@@ -11604,6 +11636,22 @@ class IndexedMinHeap {
     this.slot[node] = at;
   }
 }
+function walkBack(g, predArc, source, target) {
+  const arcs = [];
+  let node = target;
+  while (node !== source) {
+    if (arcs.length >= g.nodeCount - 1) {
+      throw new PathWalkError(source, target, "cycle");
+    }
+    const arc = predArc[node];
+    if (!(arc < g.arcCount)) {
+      throw new PathWalkError(source, target, "gap");
+    }
+    arcs.push(arc);
+    node = arcSourceIn(g.rowPtr, arc);
+  }
+  return arcs;
+}
 function walkPredArcs(g, predArc, source, target) {
   if (target === source) {
     return Uint32Array.of(source);
@@ -11611,12 +11659,7 @@ function walkPredArcs(g, predArc, source, target) {
   if (predArc[target] === INVALID_INDEX) {
     return new Uint32Array(0);
   }
-  const reversed = [target];
-  let node = target;
-  while (node !== source) {
-    node = arcSourceIn(g.rowPtr, predArc[node]);
-    reversed.push(node);
-  }
+  const reversed = [target, ...walkBack(g, predArc, source, target).map((arc) => arcSourceIn(g.rowPtr, arc))];
   const out = new Uint32Array(reversed.length);
   for (let i = 0; i < reversed.length; i++) {
     out[i] = reversed[reversed.length - 1 - i];
@@ -11627,13 +11670,7 @@ function walkPredEdges(g, predArc, source, target) {
   if (target === source || predArc[target] === INVALID_INDEX) {
     return new Uint32Array(0);
   }
-  const reversed = [];
-  let node = target;
-  while (node !== source) {
-    const arc = predArc[node];
-    reversed.push(g.arcToEdge[arc]);
-    node = arcSourceIn(g.rowPtr, arc);
-  }
+  const reversed = walkBack(g, predArc, source, target).map((arc) => g.arcToEdge[arc]);
   const out = new Uint32Array(reversed.length);
   for (let i = 0; i < reversed.length; i++) {
     out[i] = reversed[reversed.length - 1 - i];
@@ -11811,6 +11848,7 @@ export {
   DirectionOptimizedBFS,
   Graph,
   GraphBitSet,
+  PathWalkError,
   PriorityDeltaPageRank,
   PriorityQueue,
   UnionFind,