Method dijkstra

packages/graph/src/Steps.ts:5181–5261

* Dijkstra's algorithm for weighted shortest path. * Time complexity: O((V + E) log V) with a binary heap.

(
    source: GraphSource<any>,
    startVertex: Vertex<any, any>,
    targetId: ElementId | undefined,
    targetCondition: Condition | undefined,
    direction: Direction,
    edgeLabels: readonly string[],
    maxDepth: number,
    weightProperty: string,
  )

   * Time complexity: O((V + E) log V) with a binary heap.
   */
  private dijkstra(
    source: GraphSource<any>,
    startVertex: Vertex<any, any>,
    targetId: ElementId | undefined,
    targetCondition: Condition | undefined,
    direction: Direction,
    edgeLabels: readonly string[],
    maxDepth: number,
    weightProperty: string,
  ): ShortestPathResult | null {
    // Early termination: check if start is target
    if (this.isTarget(startVertex, targetId, targetCondition)) {
      return { vertices: [startVertex], edges: [], length: 0, weight: 0 };
    }

    // Dijkstra data structures
    const distances = new Map<ElementId, number>([[startVertex.id, 0]]);
    const previous = new Map<ElementId, { vertex: Vertex<any, any>; edge: Edge<any, any> } | null>([
      [startVertex.id, null],
    ]);

    // Priority queue using binary min-heap for O(log V) operations
    const pq = new MinHeap<{ vertex: Vertex<any, any>; distance: number }>(
      (a, b) => a.distance - b.distance,
    );
    pq.push({ vertex: startVertex, distance: 0 });

    let iterations = 0;
    // Safety limit: prevent DoS with hard cap independent of maxDepth
    const maxIterations = Math.min(maxDepth * 1000, 100000);

    while (pq.size > 0 && iterations < maxIterations) {
      iterations++;

      // Get vertex with minimum distance (O(log V) operation)
      const current = pq.pop();
      if (!current) break;

      const { vertex: currentVertex, distance: currentDistance } = current;

      // Skip if we've already processed this with a shorter distance
      const storedDistance = distances.get(currentVertex.id);
      if (storedDistance !== undefined && storedDistance < currentDistance) {
        continue;
      }

      // Check if we've reached the target
      if (this.isTarget(currentVertex, targetId, targetCondition)) {
        // Reconstruct path
        return this.reconstructPath(currentVertex, previous, currentDistance);
      }

      // Get neighbors
      const neighbors = this.getNeighbors(source, currentVertex, direction, edgeLabels);

      for (const { vertex: neighbor, edge } of neighbors) {
        // Get edge weight (default to 1 if not found)
        // Note: Missing or non-numeric weights default to 1 for unweighted behavior