Method traverse

packages/graph/src/Steps.ts:6380–6547

(
    source: GraphSource<any>,
    input: Iterable<TraversalPath<any, any, any>>,
    context?: QueryContext,
  )

  }

  public *traverse(
    source: GraphSource<any>,
    input: Iterable<TraversalPath<any, any, any>>,
    context?: QueryContext,
  ): IterableIterator<TraversalPath<any, any, any>> {
    const graph = source as any;
    if (typeof graph.addVertex !== "function") {
      throw new Error("MERGE requires a Graph instance");
    }

    const { pattern, onCreate, onMatch } = this.config;

    for (const path of input) {
      this.traversed++;

      let currentPath = path;
      let created = false;

      if (pattern.type === "node") {
        // Try to find existing vertex matching labels + properties
        let found: Vertex<any, any> | undefined;

        const label = pattern.labels[0] || "Node";
        const resolvedProperties = this.resolveProperties(pattern.properties, context, path);

        // First, try to find via unique index (much faster for large datasets)
        const indexManager = source.indexManager;
        if (indexManager) {
          const vertices =
            pattern.labels.length > 0
              ? graph.storage.getVertices(pattern.labels)
              : graph.storage.getVertices([]);
          const existingId = indexManager.findByUniqueProperties(
            label,
            resolvedProperties,
            vertices,
          );
          if (existingId) {
            const existingVertex = graph.getVertexById(existingId);
            if (
              existingVertex &&
              this.matchesProperties(existingVertex, pattern.properties, context)
            ) {
              found = existingVertex;
            }
          }
        }

        // If not found via unique index, fall back to linear scan
        if (!found) {
          const vertices =
            pattern.labels.length > 0 ? graph.getVertices(...pattern.labels) : graph.getVertices();

          for (const vertex of vertices) {
            if (this.matchesProperties(vertex, pattern.properties, context)) {
              found = vertex;
              break;
            }