Method bfs

packages/graph/src/Steps.ts:5123–5175

* BFS algorithm for unweighted shortest path. * Time complexity: O(V + E)

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

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

    // BFS data structures with parent pointers for efficient path reconstruction
    const visited = new Set<ElementId>([startVertex.id]);
    const previous = new Map<ElementId, { vertex: Vertex<any, any>; edge: Edge<any, any> } | null>([
      [startVertex.id, null],
    ]);
    const queue: Vertex<any, any>[] = [startVertex];

    let depth = 0;

    while (queue.length > 0 && depth < maxDepth) {
      const levelSize = queue.length;
      depth++;

      for (let i = 0; i < levelSize; i++) {
        const current = queue.shift()!;

        // Get adjacent vertices based on direction
        const neighbors = this.getNeighbors(source, current, direction, edgeLabels);

        for (const { vertex: neighbor, edge } of neighbors) {
          if (visited.has(neighbor.id)) {
            continue;
          }

          visited.add(neighbor.id);
          previous.set(neighbor.id, { vertex: current, edge });

          // Check if this is the target
          if (this.isTarget(neighbor, targetId, targetCondition)) {
            return this.reconstructPath(neighbor, previous, depth);
          }

          queue.push(neighbor);
        }
      }
    }

    return null; // No path found
  }

  /**
   * Dijkstra's algorithm for weighted shortest path.