Method settle

ui/src/components/pipeline/concurrent/stages.ts:586–639

* Run embedding sequentially on all queued nodes. The model was * pre-loaded in the constructor so init is already done by now.

(
    onProgress?: (embedded: number, total: number) => void,
  )

   * pre-loaded in the constructor so init is already done by now.
   */
  async settle(
    onProgress?: (embedded: number, total: number) => void,
  ): Promise<void> {
    const embedder = await this.ensureModel();
    if (!embedder) {
      // Init failed — drop queued nodes so the (potentially long-lived)
      // EmbedStage instance does not retain File-node references and their
      // attached source/summary properties. For large repos the queue can
      // hold thousands of entries.
      this.queue = [];
      return;
    }
    if (this.queue.length === 0) return;

    const BATCH = 8;
    for (let off = 0; off < this.queue.length; off += BATCH) {
      const batch = this.queue.slice(off, off + BATCH);
      const texts = batch.map((n) => {
        const parts = [n.name, n.type];
        const props = n.properties ?? {};
        if (typeof props.summary === 'string') parts.push(props.summary);
        if (typeof props.path === 'string') parts.push(props.path);
        return parts.join(' ');
      });

      try {
        const vectors = await embedder.embed(texts);
        const pending: { id: string; vec: number[] }[] = [];
        for (let i = 0; i < batch.length; i++) {
          if (vectors[i] && vectors[i].length > 0) {
            pending.push({ id: batch[i].id, vec: vectors[i] });
          }
        }
        if (pending.length > 0 && this.store.importVectors) {
          await this.store.importVectors(pending);
          this.embedded += pending.length;
        }
      } catch (err) {
        // Skip the bad batch but keep going — one toxic input shouldn't
        // abort the whole indexing run. Log so the failure is debuggable
        // instead of silently dropping vectors.
        console.error(
          `[EmbedStage] batch failed (offset ${off}, size ${batch.length}):`,
          err,
        );
      }

      onProgress?.(this.embedded, this.queue.length);
      await new Promise<void>((r) => setTimeout(r, 0));
    }

    // Free node references — they're persisted in the DB now
    this.queue = [];
  }

  get embeddedCount(): number {
    return this.embedded;